newrelic_rpm 3.8.1.221 → 3.9.0.229

data/lib/new_relic/agent/stats_engine/stats_hash.rb

@@ -44,7 +44,7 @@ module NewRelic
         end
       end
 
-      def record(metric_specs, value=nil, aux=nil)
+      def record(metric_specs, value=nil, aux=nil, &blk)
         Array(metric_specs).each do |metric_spec|
           stats = nil
           begin
@@ -64,19 +64,7 @@ module NewRelic
             end
           end
 
-          if block_given?
-            yield stats
-          else
-            case value
-            when Numeric
-              aux ||= value
-              stats.record_data_point(value, aux)
-            when :apdex_s, :apdex_t, :apdex_f
-              stats.record_apdex(value, aux)
-            when NewRelic::Agent::Stats
-              stats.merge!(value)
-            end
-          end
+          stats.record(value, aux, &blk)
         end
       end
 
@@ -91,13 +79,9 @@ module NewRelic
         if other.is_a?(StatsHash) && other.started_at < @started_at
           @started_at = other.started_at
         end
-        other.each do |key,val|
+        other.each do |key, val|
           begin
-            if self.has_key?(key)
-              self[key].merge!(val)
-            else
-              self[key] = val
-            end
+            merge_or_insert(key, val)
           rescue => err
             NewRelic::Agent.instance.error_collector. \
               notice_agent_error(StatsMergerError.new(key, self.fetch(key, nil), val, err))
@@ -106,10 +90,22 @@ module NewRelic
         self
       end
 
-      def resolve_scopes!(resolved_scope)
-        placeholder = StatsEngine::SCOPE_PLACEHOLDER.to_s
-        each_pair do |spec, stats|
-          spec.scope = resolved_scope if spec.scope == placeholder
+      def merge_transaction_metrics!(txn_metrics, scope)
+        txn_metrics.each_unscoped do |name, stats|
+          spec = NewRelic::MetricSpec.new(name)
+          merge_or_insert(spec, stats)
+        end
+        txn_metrics.each_scoped do |name, stats|
+          spec = NewRelic::MetricSpec.new(name, scope)
+          merge_or_insert(spec, stats)
+        end
+      end
+
+      def merge_or_insert(metric_spec, stats)
+        if self.has_key?(metric_spec)
+          self[metric_spec].merge!(stats)
+        else
+          self[metric_spec] = stats
         end
       end
     end

data/lib/new_relic/agent/supported_versions.rb

@@ -108,7 +108,8 @@ module NewRelic
       :rack =>
       {
         :type        => :web,
-        :supported   => [">= 1.0.0"],
+        :supported   => [">= 1.1.0"],
+        :deprecated  => ["~>1.0.0"],
         :url         => "https://rubygems.org/gems/rack",
         :feed        => "https://rubygems.org/gems/rack/versions.atom"
       },
@@ -242,6 +243,7 @@ module NewRelic
       :activemerchant =>
       {
         :type        => :other,
+        :supported   => [ ">= 1.25.0"],
         :url         => "https://rubygems.org/gems/activemerchant",
         :feed        => "https://rubygems.org/gems/activemerchant/versions.atom"
       },

data/lib/new_relic/agent/threading/agent_thread.rb

@@ -5,23 +5,43 @@
 module NewRelic
   module Agent
     module Threading
+      class AgentThread
 
-      class AgentThread < ::Thread
-        def initialize(label)
+        def self.create(label, &blk)
           ::NewRelic::Agent.logger.debug("Creating New Relic thread: #{label}")
-          self[:newrelic_label] = label
-          super
+          wrapped_blk = Proc.new do
+            begin
+              blk.call
+            rescue => e
+              ::NewRelic::Agent.logger.debug("Thread #{label} exited with error", e)
+            ensure
+              ::NewRelic::Agent.logger.debug("Exiting New Relic thread: #{label}")
+            end
+          end
+
+          thread = backing_thread_class.new(&wrapped_blk)
+          thread[:newrelic_label] = label
+          thread
         end
 
-        def self.bucket_thread(thread, profile_agent_code)
+        # Simplifies testing if we don't directly use ::Thread.list, so keep
+        # the accessor for it here on AgentThread to use and stub.
+        def self.list
+          backing_thread_class.list
+        end
+
+        def self.bucket_thread(thread, profile_agent_code) #THREAD_LOCAL_ACCESS
           if thread.key?(:newrelic_label)
             profile_agent_code ? :agent : :ignore
-          elsif TransactionState.in_background_transaction?(thread)
-            :background
-          elsif TransactionState.in_request_transaction?(thread)
-            :request
           else
-            :other
+            state = TransactionState.tl_state_for(thread)
+            if state.in_background_transaction?
+              :background
+            elsif state.in_request_transaction?
+              :request
+            else
+              :other
+            end
           end
         end
 
@@ -35,8 +55,19 @@ module NewRelic
           bt.reject! { |t| t.include?('/newrelic_rpm-') } unless profile_agent_code
           bt
         end
-      end
 
+        # To allow tests to swap out Thread for a synchronous alternative,
+        # surface the backing class we'll use from the class level.
+        @backing_thread_class = ::Thread
+
+        def self.backing_thread_class
+          @backing_thread_class
+        end
+
+        def self.backing_thread_class=(clazz)
+          @backing_thread_class = clazz
+        end
+      end
     end
   end
 end

data/lib/new_relic/agent/threading/backtrace_service.rb

@@ -128,13 +128,9 @@ module NewRelic
           return if @running || !self.class.is_supported?
 
           @running = true
-          self.worker_thread = AgentThread.new('Backtrace Service') do
-            begin
-              # Not passing period because we expect it's already been set.
-              self.worker_loop.run(&method(:poll))
-            ensure
-              NewRelic::Agent.logger.debug("Exiting New Relic thread: Backtrace Service")
-            end
+          self.worker_thread = AgentThread.create('Backtrace Service') do
+            # Not passing period because we expect it's already been set.
+            self.worker_loop.run(&method(:poll))
           end
         end
 

data/lib/new_relic/agent/threading/thread_profile.rb

@@ -78,11 +78,11 @@ module NewRelic
           end
         end
 
-        def truncate_to_node_count!(count_to_keep)
+        def truncate_to_node_count!(count_to_keep) #THREAD_LOCAL_ACCESS
           all_nodes = @traces.values.map { |n| n.flatten }.flatten
 
           NewRelic::Agent.instance.stats_engine.
-            record_supportability_metric_count("ThreadProfiler/NodeCount", all_nodes.size)
+            tl_record_supportability_metric_count("ThreadProfiler/NodeCount", all_nodes.size)
 
           all_nodes.sort!
           nodes_to_prune = Set.new(all_nodes[count_to_keep..-1] || [])

data/lib/new_relic/agent/traced_method_stack.rb

@@ -5,12 +5,11 @@
 module NewRelic
   module Agent
     class TracedMethodFrame
-      attr_reader :deduct_call_time_from_parent, :tag
-      attr_accessor :name, :start_time, :children_time, :type
-      def initialize(tag, start_time, deduct_call_time)
+      attr_reader :tag
+      attr_accessor :name, :start_time, :children_time, :category
+      def initialize(tag, start_time)
         @tag = tag
         @start_time = start_time
-        @deduct_call_time_from_parent = deduct_call_time
         @children_time = 0
       end
     end
@@ -24,14 +23,16 @@ module NewRelic
         @stack = []
       end
 
-      def self.push_frame(tag, time = Time.now.to_f, deduct_call_time_from_parent = true)
-        stack = NewRelic::Agent::TransactionState.get.traced_method_stack
-        stack.push_frame(tag, time, deduct_call_time_from_parent)
+      def self.tl_push_frame(tag, time = Time.now.to_f)
+        state = NewRelic::Agent::TransactionState.tl_get
+        stack = state.traced_method_stack
+        stack.push_frame(state, tag, time)
       end
 
-      def self.pop_frame(expected_frame, name, time=Time.now.to_f)
-        stack = NewRelic::Agent::TransactionState.get.traced_method_stack
-        stack.pop_frame(expected_frame, name, time)
+      def self.tl_pop_frame(expected_frame, name, time, deduct_call_time_from_parent=true)
+        state = NewRelic::Agent::TransactionState.tl_get
+        stack = state.traced_method_stack
+        stack.pop_frame(state, expected_frame, name, time, deduct_call_time_from_parent)
       end
 
       # Pushes a frame onto the transaction stack - this generates a
@@ -41,9 +42,9 @@ module NewRelic
       #
       # +tag+ should be a Symbol, and is only for debugging purposes to
       # identify this frame if the stack gets corrupted.
-      def push_frame(tag, time = Time.now.to_f, deduct_call_time_from_parent = true)
-        transaction_sampler.notice_push_frame(time) if sampler_enabled?
-        frame = TracedMethodFrame.new(tag, time, deduct_call_time_from_parent)
+      def push_frame(state, tag, time = Time.now.to_f)
+        transaction_sampler.notice_push_frame(state, time) if sampler_enabled?
+        frame = TracedMethodFrame.new(tag, time)
         @stack.push frame
         frame
       end
@@ -55,20 +56,25 @@ module NewRelic
       # push_frame call.
       #
       # +name+ will be applied to the generated transaction trace segment.
-      def pop_frame(expected_frame, name, time=Time.now.to_f)
+      def pop_frame(state, expected_frame, name, time, deduct_call_time_from_parent=true)
         frame = @stack.pop
         fail "unbalanced pop from blame stack, got #{frame ? frame.tag : 'nil'}, expected #{expected_frame ? expected_frame.tag : 'nil'}" if frame != expected_frame
 
+        note_children_time(frame, time, deduct_call_time_from_parent)
+
+        transaction_sampler.notice_pop_frame(state, name, time) if sampler_enabled?
+        frame.name = name
+        frame
+      end
+
+      def note_children_time(frame, time, deduct_call_time_from_parent)
         if !@stack.empty?
-          if frame.deduct_call_time_from_parent
+          if deduct_call_time_from_parent
             @stack.last.children_time += (time - frame.start_time)
           else
             @stack.last.children_time += frame.children_time
           end
         end
-        transaction_sampler.notice_pop_frame(name, time) if sampler_enabled?
-        frame.name = name
-        frame
       end
 
       def sampler_enabled?
@@ -79,6 +85,10 @@ module NewRelic
         Agent.instance.transaction_sampler
       end
 
+      def clear
+        @stack.clear
+      end
+
       def empty?
         @stack.empty?
       end

data/lib/new_relic/agent/transaction.rb

@@ -4,6 +4,7 @@
 
 require 'new_relic/agent/transaction_timings'
 require 'new_relic/agent/instrumentation/queue_time'
+require 'new_relic/agent/transaction_metrics'
 
 module NewRelic
   module Agent
@@ -14,162 +15,167 @@ module NewRelic
     class Transaction
 
       # for nested transactions
-      SUBTRANSACTION_PREFIX = 'Nested'.freeze
+      SUBTRANSACTION_PREFIX        = 'Nested/'.freeze
+      CONTROLLER_PREFIX            = 'Controller/'.freeze
+      MIDDLEWARE_PREFIX            = 'Middleware/Rack/'.freeze
+      TASK_PREFIX                  = 'OtherTransaction/Background/'.freeze
+      RACK_PREFIX                  = 'Controller/Rack/'.freeze
+      SINATRA_PREFIX               = 'Controller/Sinatra/'.freeze
 
-      attr_accessor :start_time  # 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 :type, :exceptions, :filtered_params,
-                    :jruby_cpu_start, :process_cpu_start
+      CONTROLLER_MIDDLEWARE_PREFIX = 'Controller/Middleware/Rack'.freeze
 
-      attr_reader :database_metric_name
+      NESTED_TRACE_STOP_OPTIONS    = { :metric => true }.freeze
+      WEB_TRANSACTION_CATEGORIES   = [:controller, :uri, :rack, :sinatra, :middleware].freeze
 
-      attr_reader :guid
-      attr_reader :stats_hash
-      attr_reader :gc_start_snapshot
+      MIDDLEWARE_SUMMARY_METRICS   = ['Middleware/all'.freeze].freeze
+      EMPTY_SUMMARY_METRICS        = [].freeze
 
-      attr_reader :name_from_child
+      # A Time instance for the start time, never nil
+      attr_accessor :start_time
 
-      # Populated with the trace sample once this transaction is completed.
-      attr_reader :transaction_trace
+      # 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 :apdex_start
+
+      attr_accessor :exceptions,
+                    :filtered_params,
+                    :jruby_cpu_start,
+                    :process_cpu_start
 
       # Give the current transaction 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
 
+      # This is the name of the model currently assigned to database
+      # measurements, overriding the default.
+      attr_reader :database_metric_name
+
+      attr_reader :guid,
+                  :metrics,
+                  :gc_start_snapshot,
+                  :category,
+                  :name_from_child
+
+      # Populated with the trace sample once this transaction is completed.
+      attr_reader :transaction_trace
+
       # Return the currently active transaction, or nil.
-      def self.current
-        TransactionState.get.current_transaction
+      def self.tl_current
+        TransactionState.tl_get.current_transaction
       end
 
-      def self.set_default_transaction_name(name, options = {})
-        txn  = current
-        name = make_transaction_name(name, options[:category])
+      def self.set_default_transaction_name(name, options = {}) #THREAD_LOCAL_ACCESS
+        txn  = tl_current
+        name = txn.make_transaction_name(name, options[:category])
 
         if txn.frame_stack.empty?
-          txn.default_name = name
-          txn.type = options[:category] if options[:category]
+          txn.set_default_transaction_name(name, options)
         else
           txn.frame_stack.last.name = name
-          txn.frame_stack.last.type = options[:category] if options[:category]
+          txn.frame_stack.last.category = options[:category] if options[:category]
         end
       end
 
-      def self.set_overriding_transaction_name(name, options = {})
-        txn = current
+      def self.set_overriding_transaction_name(name, options = {}) #THREAD_LOCAL_ACCESS
+        txn = tl_current
         return unless txn
 
-        name = make_transaction_name(name, options[:category])
+        name = txn.make_transaction_name(name, options[:category])
 
         if txn.frame_stack.empty?
-          txn.default_name  = name
-          txn.name_from_api = name
-          txn.type = options[:category] if options[:category]
+          txn.set_overriding_transaction_name(name, options)
         else
           txn.frame_stack.last.name = name
-          txn.frame_stack.last.type = options[:category] if options[:category]
+          txn.frame_stack.last.category = options[:category] if options[:category]
 
           # Parent transaction also takes this name, but only if they
           # are both/neither web transactions.
-          child_is_web_type = transaction_type_is_web?(txn.frame_stack.last.type)
-          txn_is_web_type   = transaction_type_is_web?(txn.type)
+          child_is_web_category = transaction_category_is_web?(txn.frame_stack.last.category)
+          txn_is_web_category   = transaction_category_is_web?(txn.category)
 
-          if (child_is_web_type == txn_is_web_type)
+          if (child_is_web_category == txn_is_web_category)
             txn.name_from_api = name
           end
         end
       end
 
-      def self.make_transaction_name(name, category=nil)
+      def make_transaction_name(name, category=nil)
         namer = Instrumentation::ControllerInstrumentation::TransactionNamer
-        "#{namer.category_name(category)}/#{name}"
+        "#{namer.prefix_for_category(self, category)}#{name}"
       end
 
-      def self.start(transaction_type, options)
-        transaction_type ||= :controller
-        txn = current
+      def self.start(state, category, options)
+        category ||= :controller
+        txn = state.current_transaction
 
         if txn
-          _, nested_frame = NewRelic::Agent::MethodTracer::TraceExecutionScoped.trace_execution_scoped_header({:deduct_call_time_from_parent => true}, Time.now.to_f)
+          if options[:filtered_params] && !options[:filtered_params].empty?
+            txn.filtered_params = options[:filtered_params]
+          end
+
+          nested_frame = NewRelic::Agent::MethodTracer::TraceExecutionScoped.trace_execution_scoped_header(state, Time.now.to_f)
           nested_frame.name = options[:transaction_name]
-          nested_frame.type = transaction_type
+          nested_frame.category = category
           txn.frame_stack << nested_frame
         else
-          txn = Transaction.new(transaction_type, options)
-          TransactionState.get.current_transaction = txn
-          txn.start()
+          txn = Transaction.new(category, options)
+          state.reset(txn)
+          txn.start(state)
         end
 
         txn
       end
 
-      def self.stop(end_time=Time.now, opts={})
-        txn = current
+      def self.stop(state, end_time=Time.now)
+        txn = state.current_transaction
 
         if txn.frame_stack.empty?
-          txn.stop(end_time, opts)
-          TransactionState.get.current_transaction = nil
+          txn.stop(state, end_time)
+          state.reset
         else
           nested_frame = txn.frame_stack.pop
 
           # Parent transaction inherits the name of the first child
           # to complete, if they are both/neither web transactions.
-          nested_is_web_type = transaction_type_is_web?(nested_frame.type)
-          txn_is_web_type    = transaction_type_is_web?(txn.type)
+          nested_is_web_category = transaction_category_is_web?(nested_frame.category)
+          txn_is_web_category    = transaction_category_is_web?(txn.category)
 
-          if (nested_is_web_type == txn_is_web_type)
+          if (nested_is_web_category == txn_is_web_category)
             # first child to finish wins
             txn.name_from_child ||= nested_frame.name
           end
 
+          nested_name = nested_transaction_name(nested_frame.name)
+
+          if nested_name.start_with?(MIDDLEWARE_PREFIX)
+            summary_metrics = MIDDLEWARE_SUMMARY_METRICS
+          else
+            summary_metrics = EMPTY_SUMMARY_METRICS
+          end
+
           NewRelic::Agent::MethodTracer::TraceExecutionScoped.trace_execution_scoped_footer(
+            state,
             nested_frame.start_time.to_f,
-            nested_transaction_name(nested_frame.name),
-            [],
+            nested_name,
+            summary_metrics,
             nested_frame,
-            {:metric => true},
+            NESTED_TRACE_STOP_OPTIONS,
             end_time.to_f)
         end
 
         :transaction_stopped
       end
 
-      def self.in_transaction?
-        !TransactionState.get.current_transaction.nil?
-      end
-
       def self.nested_transaction_name(name)
-        if name =~ /^Controller\//
-          "#{SUBTRANSACTION_PREFIX}/#{name}"
+        if name.start_with?(CONTROLLER_PREFIX)
+          "#{SUBTRANSACTION_PREFIX}#{name}"
         else
           name
         end
       end
 
-      def root?
-        true
-      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
-
-      def self.freeze_name_and_execute_if_not_ignored
-        self.current && self.current.freeze_name_and_execute_if_not_ignored { yield if block_given? }
-      end
-
       @@java_classes_loaded = false
 
       if defined? JRuby
@@ -184,7 +190,7 @@ module NewRelic
 
       attr_reader :frame_stack
 
-      def initialize(type, options)
+      def initialize(category, options)
         @frame_stack = []
 
         @default_name    = Helper.correctly_encoded(options[:transaction_name])
@@ -192,7 +198,7 @@ module NewRelic
         @name_from_api   = nil
         @frozen_name     = nil
 
-        @type = type
+        @category = category
         @start_time = Time.now
         @apdex_start = options[:apdex_start_time] || @start_time
         @jruby_cpu_start = jruby_cpu_time
@@ -201,10 +207,12 @@ module NewRelic
         @filtered_params = options[:filtered_params] || {}
         @request = options[:request]
         @exceptions = {}
-        @stats_hash = StatsHash.new
+        @metrics = TransactionMetrics.new
         @guid = generate_guid
+
         @ignore_this_transaction = false
-        TransactionState.get.most_recent_transaction = self
+        @ignore_apdex = false
+        @ignore_enduser = false
       end
 
       def noticed_error_ids
@@ -227,6 +235,24 @@ module NewRelic
         @name_from_api = Helper.correctly_encoded(name)
       end
 
+      def set_default_transaction_name(name, options)
+        self.default_name = name
+        @category = options[:category] if options[:category]
+      end
+
+      def set_overriding_transaction_name(name, options)
+        self.name_from_api = name
+        set_default_transaction_name(name, options)
+      end
+
+      def best_category
+        if frame_stack.empty?
+          category
+        else
+          frame_stack.last.category
+        end
+      end
+
       def best_name
         return @frozen_name   if @frozen_name
         return @name_from_api if @name_from_api
@@ -246,13 +272,22 @@ module NewRelic
         (@name_from_api || @name_from_child || @default_name) ? true : false
       end
 
+      def promoted_transaction_name(name)
+        if name.start_with?(MIDDLEWARE_PREFIX)
+          "#{CONTROLLER_PREFIX}#{name}"
+        else
+          name
+        end
+      end
+
       def freeze_name_and_execute_if_not_ignored
         if !name_frozen?
-          name = NewRelic::Agent.instance.transaction_rules.rename(best_name)
+          name = promoted_transaction_name(best_name)
+          name = NewRelic::Agent.instance.transaction_rules.rename(name)
           @name_frozen = true
 
           if name.nil?
-            @ignore_this_transaction = true
+            ignore!
             @frozen_name = best_name
           else
             @frozen_name = name
@@ -274,26 +309,24 @@ module NewRelic
 
       # Indicate that we are entering a measured controller action or task.
       # Make sure you unwind every push with a pop call.
-      def start()
-        return if !NewRelic::Agent.is_execution_traced?
+      def start(state)
+        return if !state.is_execution_traced?
 
-        transaction_sampler.on_start_transaction(start_time, uri, filtered_params)
-        sql_sampler.on_start_transaction(start_time, uri, filtered_params)
+        transaction_sampler.on_start_transaction(state, start_time, uri)
+        sql_sampler.on_start_transaction(state, start_time, uri)
         NewRelic::Agent.instance.events.notify(:start_transaction)
         NewRelic::Agent::BusyCalculator.dispatcher_start(start_time)
 
-        @trace_options = {
-                    :metric                       => true,
-                    :scoped_metric                => false,
-                    :deduct_call_time_from_parent => true
-                  }
-        _, @expected_scope = NewRelic::Agent::MethodTracer::TraceExecutionScoped.trace_execution_scoped_header(@trace_options, start_time.to_f)
+        @trace_options = { :metric => true, :scoped_metric => false }
+        @expected_scope = NewRelic::Agent::MethodTracer::TraceExecutionScoped.trace_execution_scoped_header(state, start_time.to_f)
       end
 
       # Indicate that you don't want to keep the currently saved transaction
       # information
-      def self.abort_transaction!
-        current.abort_transaction! if current
+      def self.abort_transaction! #THREAD_LOCAL_ACCESS
+        state = NewRelic::Agent::TransactionState.tl_get
+        txn = state.current_transaction
+        txn.abort_transaction!(state) if txn
       end
 
       # For the current web transaction, return the path of the URI minus the host part and query string, or nil.
@@ -307,8 +340,8 @@ module NewRelic
       end
 
       # Call this to ensure that the current transaction is not saved
-      def abort_transaction!
-        transaction_sampler.ignore_transaction
+      def abort_transaction!(state)
+        transaction_sampler.ignore_transaction(state)
       end
 
       def summary_metrics
@@ -316,91 +349,102 @@ module NewRelic
         metric_parser.summary_metrics
       end
 
-      def stop(end_time, opts)
-        return if !NewRelic::Agent.is_execution_traced?
-        freeze_name_and_execute_if_not_ignored
+      def needs_middleware_summary_metrics?(name)
+        name.start_with?(MIDDLEWARE_PREFIX)
+      end
 
-        name    = @frozen_name
-        metrics = summary_metrics
+      def stop(state, end_time)
+        return if !state.is_execution_traced?
+        freeze_name_and_execute_if_not_ignored
 
         if @name_from_child
           name = Transaction.nested_transaction_name(@default_name)
-          metrics << @frozen_name
           @trace_options[:scoped_metric] = true
+        else
+          name = @frozen_name
+        end
+
+        # These metrics are recorded here instead of in record_summary_metrics
+        # in order to capture the exclusive time associated with the outer-most
+        # TT node.
+        if needs_middleware_summary_metrics?(name)
+          summary_metrics_with_exclusive_time = MIDDLEWARE_SUMMARY_METRICS
+        else
+          summary_metrics_with_exclusive_time = EMPTY_SUMMARY_METRICS
         end
 
         NewRelic::Agent::MethodTracer::TraceExecutionScoped.trace_execution_scoped_footer(
+          state,
           start_time.to_f,
           name,
-          metrics,
+          summary_metrics_with_exclusive_time,
           @expected_scope,
           @trace_options,
           end_time.to_f)
 
-        log_underflow if @type.nil?
         NewRelic::Agent::BusyCalculator.dispatcher_finish(end_time)
 
-        unless @ignore_this_transaction
-          # these record metrics so need to be done before merging stats
+        commit!(state, end_time, name) unless @ignore_this_transaction
+      end
 
-          # this one records metrics and wants to happen
-          # before the transaction sampler is finished
-          record_transaction_cpu
-          gc_stop_snapshot = NewRelic::Agent::StatsEngine::GCProfiler.take_snapshot
-          gc_delta = NewRelic::Agent::StatsEngine::GCProfiler.record_delta(
-              gc_start_snapshot, gc_stop_snapshot)
-          @transaction_trace = transaction_sampler.on_finishing_transaction(self, Time.now, gc_delta)
-          sql_sampler.on_finishing_transaction(@frozen_name)
+      def commit!(state, end_time, outermost_segment_name)
+        record_transaction_cpu(state)
+        gc_stop_snapshot = NewRelic::Agent::StatsEngine::GCProfiler.take_snapshot
+        gc_delta = NewRelic::Agent::StatsEngine::GCProfiler.record_delta(
+            gc_start_snapshot, gc_stop_snapshot)
+        @transaction_trace = transaction_sampler.on_finishing_transaction(state, self, end_time, gc_delta)
+        sql_sampler.on_finishing_transaction(state, @frozen_name)
 
-          record_apdex(end_time, opts[:exception_encountered]) unless opts[:ignore_apdex]
-          NewRelic::Agent::Instrumentation::QueueTime.record_frontend_metrics(apdex_start, start_time) if queue_time > 0.0
-          NewRelic::Agent::TransactionState.get.request_ignore_enduser = true if opts[:ignore_enduser]
+        record_summary_metrics(outermost_segment_name, end_time)
+        record_apdex(state, end_time) unless ignore_apdex?
+        NewRelic::Agent::Instrumentation::QueueTime.record_frontend_metrics(apdex_start, start_time) if queue_time > 0.0
 
-          record_exceptions
-          merge_stats_hash
+        record_exceptions
+        merge_metrics
 
-          send_transaction_finished_event(start_time, end_time)
-        end
+        send_transaction_finished_event(state, start_time, end_time)
+      end
+
+      # The summary metrics recorded by this method all end up with a duration
+      # equal to the transaction itself, and an exclusive time of zero.
+      def record_summary_metrics(outermost_segment_name, end_time)
+        metrics = summary_metrics
+        metrics << @frozen_name unless @frozen_name == outermost_segment_name
+        @metrics.record_unscoped(metrics, end_time - start_time, 0)
       end
 
       # This event is fired when the transaction is fully completed. The metric
       # values and sampler can't be successfully modified from this event.
-      def send_transaction_finished_event(start_time, end_time)
+      def send_transaction_finished_event(state, start_time, end_time)
         payload = {
           :name             => @frozen_name,
-          :type             => @type,
           :start_timestamp  => start_time.to_f,
           :duration         => end_time.to_f - start_time.to_f,
-          :metrics          => @stats_hash,
+          :metrics          => @metrics,
           :custom_params    => custom_parameters
         }
-        append_guid_to(payload)
-        append_referring_transaction_guid_to(payload)
+        append_guid_to(state, payload)
+        append_referring_transaction_guid_to(state, payload)
 
         agent.events.notify(:transaction_finished, payload)
       end
 
-      def append_guid_to(payload)
-        guid = NewRelic::Agent::TransactionState.get.request_guid_for_event
+      def append_guid_to(state, payload)
+        guid = state.request_guid_for_event
         if guid
           payload[:guid] = guid
         end
       end
 
-      def append_referring_transaction_guid_to(payload)
-        referring_guid = NewRelic::Agent.instance.cross_app_monitor.client_referring_transaction_guid
+      def append_referring_transaction_guid_to(state, payload)
+        referring_guid = NewRelic::Agent.instance.cross_app_monitor.client_referring_transaction_guid(state)
         if referring_guid
           payload[:referring_transaction_guid] = referring_guid
         end
       end
 
-      def log_underflow
-        NewRelic::Agent.logger.error "Underflow in transaction: #{caller.join("\n   ")}"
-      end
-
-      def merge_stats_hash
-        stats_hash.resolve_scopes!(best_name)
-        NewRelic::Agent.instance.stats_engine.merge!(stats_hash)
+      def merge_metrics
+        NewRelic::Agent.instance.stats_engine.merge_transaction_metrics!(@metrics, best_name)
       end
 
       def record_exceptions
@@ -420,13 +464,14 @@ module NewRelic
       # * <tt>:custom_params</tt> => Custom parameters
       # Anything left over is treated as custom params
 
-      def self.notice_error(e, options={})
+      def self.notice_error(e, options={}) #THREAD_LOCAL_ACCESS
         options = extract_request_options(options)
-        if current
-          current.notice_error(e, options)
+        state = NewRelic::Agent::TransactionState.tl_get
+        txn = state.current_transaction
+        if txn
+          txn.notice_error(e, options)
         else
-          options = extract_finished_transaction_options(options)
-          agent.error_collector.notice_error(e, options)
+          NewRelic::Agent.instance.error_collector.notice_error(e, options)
         end
       end
 
@@ -439,61 +484,41 @@ module NewRelic
         options
       end
 
-      # If we aren't currently in a transaction, but found the remains of one
-      # just finished in the TransactionState, use those custom params!
-      def self.extract_finished_transaction_options(options)
-        finished_txn = NewRelic::Agent::TransactionState.get.most_recent_transaction
-        if finished_txn
-          custom_params = options.fetch(:custom_params, {})
-          custom_params.merge!(finished_txn.custom_parameters)
-          options = options.merge(:custom_params => custom_params)
-          options[:metric] = finished_txn.best_name
-        end
-        options
-      end
 
       # Do not call this.  Invoke the class method instead.
-      def notice_error(e, options={}) # :nodoc:
+      def notice_error(error, options={}) # :nodoc:
         options[:referer] = referer if referer
-        options[:request_params] = filtered_params if filtered_params
-        options[:uri] = uri if uri
-        options.merge!(custom_parameters)
-        if !@exceptions.keys.include?(e)
-          @exceptions[e] = options
-        end
-      end
 
-      # Add context parameters to the transaction.  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
+        if filtered_params && !filtered_params.empty?
+          options[:request_params] = filtered_params
+        end
 
-      def self.custom_parameters
-        (current && current.custom_parameters) ? current.custom_parameters : {}
-      end
+        options[:uri] = uri if uri
+        options.merge!(custom_parameters)
 
-      class << self
-        alias_method :user_attributes, :custom_parameters
-        alias_method :set_user_attributes, :add_custom_parameters
+        if @exceptions[error]
+          @exceptions[error].merge! options
+        else
+          @exceptions[error] = options
+        end
       end
 
-      APDEX_METRIC_SPEC = NewRelic::MetricSpec.new('Apdex').freeze
+      APDEX_METRIC = 'Apdex'.freeze
 
-      def record_apdex(end_time=Time.now, is_error=nil)
-        return unless recording_web_transaction? && NewRelic::Agent.is_execution_traced?
+      def record_apdex(state, end_time=Time.now)
+        return unless recording_web_transaction? && state.is_execution_traced?
 
         freeze_name_and_execute_if_not_ignored do
           action_duration = end_time - start_time
           total_duration  = end_time - apdex_start
-          is_error = is_error.nil? ? !exceptions.empty? : is_error
+          is_error = !notable_exceptions.empty?
 
           apdex_bucket_global = self.class.apdex_bucket(total_duration,  is_error, apdex_t)
           apdex_bucket_txn    = self.class.apdex_bucket(action_duration, is_error, apdex_t)
 
-          @stats_hash.record(APDEX_METRIC_SPEC, apdex_bucket_global, apdex_t)
-          txn_apdex_metric = NewRelic::MetricSpec.new(@frozen_name.gsub(/^[^\/]+\//, 'Apdex/'))
-          @stats_hash.record(txn_apdex_metric, apdex_bucket_txn, apdex_t)
+          @metrics.record_unscoped(APDEX_METRIC, apdex_bucket_global, apdex_t)
+          txn_apdex_metric = @frozen_name.gsub(/^[^\/]+\//, 'Apdex/')
+          @metrics.record_unscoped(txn_apdex_metric, apdex_bucket_txn, apdex_t)
         end
       end
 
@@ -549,16 +574,17 @@ module NewRelic
       #
       # @api public
       #
-      def self.recording_web_transaction?
-        self.current && self.current.recording_web_transaction?
+      def self.recording_web_transaction? #THREAD_LOCAL_ACCESS
+        txn = tl_current
+        txn && txn.recording_web_transaction?
       end
 
-      def self.transaction_type_is_web?(type)
-        [:controller, :uri, :rack, :sinatra].include?(type)
+      def self.transaction_category_is_web?(category)
+        WEB_TRANSACTION_CATEGORIES.include?(category)
       end
 
       def recording_web_transaction?
-        self.class.transaction_type_is_web?(@type)
+        self.class.transaction_category_is_web?(@category)
       end
 
       # Make a safe attempt to get the referer from a request object, generally successful when
@@ -582,11 +608,6 @@ module NewRelic
       end
 
 
-
-      def self.record_apdex(end_time, is_error)
-        current && current.record_apdex(end_time, is_error)
-      end
-
       def self.apdex_bucket(duration, failed, apdex_t)
         case
         when failed
@@ -614,9 +635,41 @@ module NewRelic
         jruby_cpu_time - @jruby_cpu_start
       end
 
-      def record_transaction_cpu
+      def record_transaction_cpu(state)
         burn = cpu_burn
-        transaction_sampler.notice_transaction_cpu_time(burn) if burn
+        if burn
+          transaction_sampler.notice_transaction_cpu_time(state, burn)
+        end
+      end
+
+      def ignore!
+        @ignore_this_transaction = true
+      end
+
+      def ignore?
+        @ignore_this_transaction
+      end
+
+      def ignore_apdex!
+        @ignore_apdex = true
+      end
+
+      def ignore_apdex?
+        @ignore_apdex
+      end
+
+      def ignore_enduser!
+        @ignore_enduser = true
+      end
+
+      def ignore_enduser?
+        @ignore_enduser
+      end
+
+      def notable_exceptions
+        @exceptions.keys.select do |exception|
+          !NewRelic::Agent.instance.error_collector.error_is_ignored?(exception)
+        end
       end
 
       private