newrelic_rpm 3.8.0.218 → 3.8.1.221

data/lib/new_relic/agent/request_sampler.rb

@@ -102,7 +102,6 @@ class NewRelic::Agent::RequestSampler
     end
 
     NewRelic::Agent.config.register_callback(:'analytics_events.enabled') do |enabled|
-      NewRelic::Agent.logger.info "%sabling the Request Sampler." % [ enabled ? 'En' : 'Dis' ]
       @enabled = enabled
     end
   end

data/lib/new_relic/agent/rules_engine.rb

@@ -8,9 +8,7 @@ module NewRelic
       include Enumerable
       extend Forwardable
 
-      def_delegators :@rules, :size, :<<, :inspect, :each
-
-      attr_accessor :rules
+      def_delegators :@rules, :size, :inspect, :each, :clear
 
       def self.from_specs(specs)
         rules = (specs || []).map { |spec| Rule.new(spec) }
@@ -18,19 +16,36 @@ module NewRelic
       end
 
       def initialize(rules=[])
-        @rules = rules
+        @rules = rules.sort
+      end
+
+      def << rule
+        @rules << rule
+        @rules.sort!
+        @rules
       end
 
       def rename(original_string)
-        @rules.sort.inject(original_string) do |string,rule|
+        @rules.inject(original_string) do |string,rule|
           if rule.each_segment
-            result, matched = rule.map_to_list(string.split('/'))
-            result = result.join('/')
+            segments = string.split('/')
+
+            # If string looks like '/foo/bar', we want to
+            # ignore the empty string preceding the first slash.
+            add_preceding_slash = false
+            if segments[0] == ''
+              segments.shift
+              add_preceding_slash = true
+            end
+
+            result, matched = rule.map_to_list(segments)
+            result = result.join('/') if !result.nil?
+            result = '/'+result if add_preceding_slash
           else
             result, matched = rule.apply(string)
           end
 
-          break result if matched && rule.terminate_chain
+          break result if (matched && rule.terminate_chain) || result.nil?
           result
         end
       end
@@ -47,7 +62,7 @@ module NewRelic
             raise ArgumentError.new('must specify replacement when ignore is false')
           end
 
-          @match_expression = Regexp.new(options['match_expression'])
+          @match_expression = Regexp.new(options['match_expression'], Regexp::IGNORECASE)
           @replacement      = options['replacement']
           @ignore           = options['ignore'] || false
           @eval_order       = options['eval_order'] || 0
@@ -57,9 +72,18 @@ module NewRelic
         end
 
         def apply(string)
-          method = @replace_all ? :gsub : :sub
-          result = string.send(method, @match_expression, @replacement)
-          [result, result != string]
+          if @ignore
+            if string.match @match_expression
+              [nil, true]
+            else
+              [string, false]
+            end
+          else
+            method = @replace_all ? :gsub : :sub
+            result = string.send(method, @match_expression, @replacement)
+            match_found = ($~ != nil)
+            [result, match_found]
+          end
         end
 
         def map_to_list(list)

data/lib/new_relic/agent/shim_agent.rb

@@ -14,7 +14,6 @@ module NewRelic
       def initialize
         super
         @stats_engine.extend NewRelic::Agent::StatsEngine::Shim
-        @stats_engine.extend NewRelic::Agent::StatsEngine::Transactions::Shim
         @transaction_sampler.extend NewRelic::Agent::TransactionSampler::Shim
         @sql_sampler.extend NewRelic::Agent::SqlSampler::Shim
         @error_collector.extend NewRelic::Agent::ErrorCollector::Shim

data/lib/new_relic/agent/sql_sampler.rb

@@ -11,14 +11,12 @@ require 'new_relic/control'
 
 module NewRelic
   module Agent
-
     class SqlSampler
 
       # Module defining methods stubbed out when the agent is disabled
-      module Shim #:nodoc:
-        def notice_scope_empty(*args); end
-        def notice_first_scope_push(*args); end
-        def notice_transaction(*args); end
+      module Shim
+        def on_start_transaction(*args); end
+        def on_finishing_transaction(*args); end
       end
 
       attr_reader :disabled
@@ -43,23 +41,18 @@ module NewRelic
           Agent.config[:'transaction_tracer.enabled']
       end
 
-      def notice_transaction(uri=nil, params={})
+      def on_start_transaction(start_time, uri=nil, params={})
+        TransactionState.get.sql_sampler_transaction_data = TransactionSqlData.new
+
         if NewRelic::Agent.instance.transaction_sampler.builder
           guid = NewRelic::Agent.instance.transaction_sampler.builder.sample.guid
         end
+
         if Agent.config[:'slow_sql.enabled'] && transaction_data
           transaction_data.set_transaction_info(uri, params, guid)
         end
       end
 
-      def notice_first_scope_push(time)
-        create_transaction_data
-      end
-
-      def create_transaction_data
-        TransactionState.get.sql_sampler_transaction_data = TransactionSqlData.new
-      end
-
       def transaction_data
         TransactionState.get.sql_sampler_transaction_data
       end
@@ -69,7 +62,7 @@ module NewRelic
       end
 
       # This is called when we are done with the transaction.
-      def notice_scope_empty(name, time=Time.now)
+      def on_finishing_transaction(name, time=Time.now)
         data = transaction_data
         data.set_transaction_name(name)
         clear_transaction_data

data/lib/new_relic/agent/stats_engine.rb

@@ -4,7 +4,6 @@
 
 require 'new_relic/agent/stats_engine/metric_stats'
 require 'new_relic/agent/stats_engine/samplers'
-require 'new_relic/agent/stats_engine/transactions'
 require 'new_relic/agent/stats_engine/gc_profiler'
 require 'new_relic/agent/stats_engine/stats_hash'
 
@@ -14,15 +13,12 @@ module NewRelic
     class StatsEngine
       include MetricStats
       include Samplers
-      include Transactions
 
       attr_accessor :metric_rules
 
       def initialize
-        # Makes the unit tests happy
-        NewRelic::Agent::TransactionState.get.clear_stats_scope_stack
-        @stats_lock = Mutex.new
-        @stats_hash = StatsHash.new
+        @stats_lock   = Mutex.new
+        @stats_hash   = StatsHash.new
         @metric_rules = RulesEngine.new
       end
 

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

@@ -148,8 +148,10 @@ module NewRelic
           renamed_stats = NewRelic::Agent::StatsHash.new(stats_hash.started_at)
           stats_hash.each do |spec, stats|
             new_name = rules_engine.rename(spec.name)
-            new_spec = NewRelic::MetricSpec.new(new_name, spec.scope)
-            renamed_stats[new_spec].merge!(stats)
+            unless new_name.nil?
+              new_spec = NewRelic::MetricSpec.new(new_name, spec.scope)
+              renamed_stats[new_spec].merge!(stats)
+            end
           end
           renamed_stats
         end
@@ -189,6 +191,10 @@ module NewRelic
         def in_transaction?
           !!transaction_stats_hash
         end
+
+        def transaction_stats_hash
+          Transaction.current && Transaction.current.stats_hash
+        end
       end
     end
   end

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

@@ -49,7 +49,7 @@ module NewRelic
           stats = nil
           begin
             stats = self[metric_spec]
-          rescue => e
+          rescue NoMethodError => e
             # This only happen in the case of a corrupted default_proc
             # Side-step it manually, notice the issue, and carry on....
             NewRelic::Agent.instance.error_collector. \

data/lib/new_relic/agent/supported_versions.rb

@@ -140,7 +140,7 @@ module NewRelic
       :mongo =>
       {
         :type        => :database,
-        :supported   => ["~>1.8.0", "~>1.9.0"],
+        :supported   => ["~>1.8.0", "~>1.9.0", "~>1.10.0"],
         :url         => "https://rubygems.org/gems/mongo",
         :feed        => "https://rubygems.org/gems/mongo/versions.atom"
       },

data/lib/new_relic/agent/traced_method_stack.rb

@@ -0,0 +1,87 @@
+# 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.
+
+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)
+        @tag = tag
+        @start_time = start_time
+        @deduct_call_time_from_parent = deduct_call_time
+        @children_time = 0
+      end
+    end
+
+    # TracedMethodStack is responsible for tracking the push and pop of methods
+    # that we are tracing, notifying the transaction sampler, and calculating
+    # exclusive time when a method is complete. This is allowed whether a
+    # transaction is in progress not.
+    class TracedMethodStack
+      def initialize
+        @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)
+      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)
+      end
+
+      # Pushes a frame onto the transaction stack - this generates a
+      # TransactionSample::Segment at the end of transaction execution.
+      #
+      # The generated segment won't be named until pop_frame is called.
+      #
+      # +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)
+        @stack.push frame
+        frame
+      end
+
+      # Pops a frame off the transaction stack - this updates the transaction
+      # sampler that we've finished execution of a traced method.
+      #
+      # +expected_frame+ should be TracedMethodFrame from the corresponding
+      # push_frame call.
+      #
+      # +name+ will be applied to the generated transaction trace segment.
+      def pop_frame(expected_frame, name, time=Time.now.to_f)
+        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
+
+        if !@stack.empty?
+          if frame.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?
+        Agent.config[:'transaction_tracer.enabled'] || Agent.config[:developer_mode]
+      end
+
+      def transaction_sampler
+        Agent.instance.transaction_sampler
+      end
+
+      def empty?
+        @stack.empty?
+      end
+    end
+  end
+end

data/lib/new_relic/agent/transaction.rb

@@ -2,8 +2,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/transaction/pop'
 require 'new_relic/agent/transaction_timings'
+require 'new_relic/agent/instrumentation/queue_time'
 
 module NewRelic
   module Agent
@@ -12,21 +12,25 @@ module NewRelic
     #
     # @api public
     class Transaction
-      # helper module refactored out of the `pop` method
-      include Pop
+
+      # for nested transactions
+      SUBTRANSACTION_PREFIX = 'Nested'.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, :force_flag,
-                    :jruby_cpu_start, :process_cpu_start, :database_metric_name)
+      attr_accessor :type, :exceptions, :filtered_params,
+                    :jruby_cpu_start, :process_cpu_start
+
+      attr_reader :database_metric_name
 
-      attr_reader :name
       attr_reader :guid
       attr_reader :stats_hash
       attr_reader :gc_start_snapshot
 
+      attr_reader :name_from_child
+
       # Populated with the trace sample once this transaction is completed.
       attr_reader :transaction_trace
 
@@ -37,32 +41,115 @@ module NewRelic
 
       # Return the currently active transaction, or nil.
       def self.current
-        self.stack.last
+        TransactionState.get.current_transaction
       end
 
-      def self.parent
-        self.stack[-2]
+      def self.set_default_transaction_name(name, options = {})
+        txn  = current
+        name = make_transaction_name(name, options[:category])
+
+        if txn.frame_stack.empty?
+          txn.default_name = name
+          txn.type = options[:category] if options[:category]
+        else
+          txn.frame_stack.last.name = name
+          txn.frame_stack.last.type = options[:category] if options[:category]
+        end
       end
 
-      def self.start(transaction_type, options={})
-        txn = Transaction.new(transaction_type, options)
-        txn.start(transaction_type)
-        self.stack.push(txn)
-        return txn
+      def self.set_overriding_transaction_name(name, options = {})
+        txn = current
+        return unless txn
+
+        name = 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]
+        else
+          txn.frame_stack.last.name = name
+          txn.frame_stack.last.type = 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)
+
+          if (child_is_web_type == txn_is_web_type)
+            txn.name_from_api = name
+          end
+        end
       end
 
-      def self.stop(metric_name=nil, end_time=Time.now)
-        txn = self.stack.last
-        txn.stop(metric_name, end_time) if txn
-        return self.stack.pop
+      def self.make_transaction_name(name, category=nil)
+        namer = Instrumentation::ControllerInstrumentation::TransactionNamer
+        "#{namer.category_name(category)}/#{name}"
       end
 
-      def self.stack
-        TransactionState.get.current_transaction_stack
+      def self.start(transaction_type, options)
+        transaction_type ||= :controller
+        txn = current
+
+        if txn
+          _, nested_frame = NewRelic::Agent::MethodTracer::TraceExecutionScoped.trace_execution_scoped_header({:deduct_call_time_from_parent => true}, Time.now.to_f)
+          nested_frame.name = options[:transaction_name]
+          nested_frame.type = transaction_type
+          txn.frame_stack << nested_frame
+        else
+          txn = Transaction.new(transaction_type, options)
+          TransactionState.get.current_transaction = txn
+          txn.start()
+        end
+
+        txn
+      end
+
+      def self.stop(end_time=Time.now, opts={})
+        txn = current
+
+        if txn.frame_stack.empty?
+          txn.stop(end_time, opts)
+          TransactionState.get.current_transaction = nil
+        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)
+
+          if (nested_is_web_type == txn_is_web_type)
+            # first child to finish wins
+            txn.name_from_child ||= nested_frame.name
+          end
+
+          NewRelic::Agent::MethodTracer::TraceExecutionScoped.trace_execution_scoped_footer(
+            nested_frame.start_time.to_f,
+            nested_transaction_name(nested_frame.name),
+            [],
+            nested_frame,
+            {:metric => true},
+            end_time.to_f)
+        end
+
+        :transaction_stopped
       end
 
       def self.in_transaction?
-        !self.stack.empty?
+        !TransactionState.get.current_transaction.nil?
+      end
+
+      def self.nested_transaction_name(name)
+        if name =~ /^Controller\//
+          "#{SUBTRANSACTION_PREFIX}/#{name}"
+        else
+          name
+        end
+      end
+
+      def root?
+        true
       end
 
       # This is the name of the model currently assigned to database
@@ -79,8 +166,8 @@ module NewRelic
         NewRelic::Agent.instance
       end
 
-      def self.freeze_name
-        self.current && self.current.freeze_name
+      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
@@ -91,77 +178,116 @@ module NewRelic
           java_import 'java.lang.management.ManagementFactory'
           java_import 'com.sun.management.OperatingSystemMXBean'
           @@java_classes_loaded = true
-        rescue => e
+        rescue
         end
       end
 
-      attr_reader :depth
+      attr_reader :frame_stack
+
+      def initialize(type, options)
+        @frame_stack = []
+
+        @default_name    = Helper.correctly_encoded(options[:transaction_name])
+        @name_from_child = nil
+        @name_from_api   = nil
+        @frozen_name     = nil
 
-      def initialize(type=:controller, options={})
         @type = type
         @start_time = Time.now
-        @apdex_start = @start_time
+        @apdex_start = options[:apdex_start_time] || @start_time
         @jruby_cpu_start = jruby_cpu_time
         @process_cpu_start = process_cpu
         @gc_start_snapshot = NewRelic::Agent::StatsEngine::GCProfiler.take_snapshot
         @filtered_params = options[:filtered_params] || {}
-        @force_flag = options[:force]
         @request = options[:request]
         @exceptions = {}
         @stats_hash = StatsHash.new
         @guid = generate_guid
-        TransactionState.get.transaction = self
+        @ignore_this_transaction = false
+        TransactionState.get.most_recent_transaction = self
       end
 
       def noticed_error_ids
         @noticed_error_ids ||= []
       end
 
-      def name=(name)
-        if !@name_frozen
-          @name = name
-        else
-          NewRelic::Agent.logger.warn("Attempted to rename transaction to '#{name}' after transaction name was already frozen as '#{@name}'.")
-        end
+      def default_name=(name)
+        @default_name = Helper.correctly_encoded(name)
       end
 
-      def name_set?
-        @name && @name != NewRelic::Agent::UNKNOWN_METRIC
+      def name_from_child=(name)
+        @name_from_child = Helper.correctly_encoded(name)
       end
 
-      def freeze_name
-        return if name_frozen?
-        @name = NewRelic::Agent.instance.transaction_rules.rename(@name)
-        @name_frozen = true
+      def name_from_api=(name)
+        if @frozen_name
+          NewRelic::Agent.logger.warn("Attempted to rename transaction to '#{name}' after transaction name was already frozen as '#{@frozen_name}'.")
+        end
+
+        @name_from_api = Helper.correctly_encoded(name)
       end
 
-      def name_frozen?
-        @name_frozen
+      def best_name
+        return @frozen_name   if @frozen_name
+        return @name_from_api if @name_from_api
+
+        if @name_from_child
+          return @name_from_child
+        elsif !@frame_stack.empty?
+          return @frame_stack.last.name
+        end
+
+        return @default_name if @default_name
+
+        NewRelic::Agent::UNKNOWN_METRIC
       end
 
-      def parent
-        has_parent? && self.class.stack[-2]
+      def name_set?
+        (@name_from_api || @name_from_child || @default_name) ? true : false
       end
 
-      def root?
-        self.class.stack.size == 1
+      def freeze_name_and_execute_if_not_ignored
+        if !name_frozen?
+          name = NewRelic::Agent.instance.transaction_rules.rename(best_name)
+          @name_frozen = true
+
+          if name.nil?
+            @ignore_this_transaction = true
+            @frozen_name = best_name
+          else
+            @frozen_name = name
+          end
+        end
+
+        if block_given? && !@ignore_this_transaction
+          yield
+        end
       end
 
-      def has_parent?
-        self.class.stack.size > 1
+      def name_frozen?
+        @frozen_name ? true : false
+      end
+
+      def ignored?
+        @ignore_this_transaction
       end
 
       # Indicate that we are entering a measured controller action or task.
       # Make sure you unwind every push with a pop call.
-      def start(transaction_type)
-        @name = NewRelic::Agent::UNKNOWN_METRIC
+      def start()
+        return if !NewRelic::Agent.is_execution_traced?
 
-        transaction_sampler.notice_first_scope_push(start_time)
-        sql_sampler.notice_first_scope_push(start_time)
+        transaction_sampler.on_start_transaction(start_time, uri, filtered_params)
+        sql_sampler.on_start_transaction(start_time, uri, filtered_params)
+        NewRelic::Agent.instance.events.notify(:start_transaction)
+        NewRelic::Agent::BusyCalculator.dispatcher_start(start_time)
 
-        agent.stats_engine.start_transaction
-        transaction_sampler.notice_transaction(uri, filtered_params)
-        sql_sampler.notice_transaction(uri, filtered_params)
+        @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)
       end
 
       # Indicate that you don't want to keep the currently saved transaction
@@ -185,35 +311,55 @@ module NewRelic
         transaction_sampler.ignore_transaction
       end
 
+      def summary_metrics
+        metric_parser = NewRelic::MetricParser::MetricParser.for_metric_named(@frozen_name)
+        metric_parser.summary_metrics
+      end
+
+      def stop(end_time, opts)
+        return if !NewRelic::Agent.is_execution_traced?
+        freeze_name_and_execute_if_not_ignored
+
+        name    = @frozen_name
+        metrics = summary_metrics
+
+        if @name_from_child
+          name = Transaction.nested_transaction_name(@default_name)
+          metrics << @frozen_name
+          @trace_options[:scoped_metric] = true
+        end
+
+        NewRelic::Agent::MethodTracer::TraceExecutionScoped.trace_execution_scoped_footer(
+          start_time.to_f,
+          name,
+          metrics,
+          @expected_scope,
+          @trace_options,
+          end_time.to_f)
 
-      # Unwind one stack level.  It knows if it's back at the outermost caller and
-      # does the appropriate wrapup of the context.
-      def stop(fallback_name=::NewRelic::Agent::UNKNOWN_METRIC, end_time=Time.now)
-        @name = fallback_name unless name_set? || name_frozen?
-        freeze_name
         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
 
-        # these record metrics so need to be done before merging stats
-        if self.root?
           # this one records metrics and wants to happen
           # before the transaction sampler is finished
-          if traced?
-            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)
-          end
-          @transaction_trace = transaction_sampler.notice_scope_empty(self, Time.now, gc_delta)
-          sql_sampler.notice_scope_empty(@name)
-        end
+          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)
+
+          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_exceptions
-        merge_stats_hash
+          record_exceptions
+          merge_stats_hash
 
-        # these tear everything down so need to be done after merging stats
-        if self.root?
           send_transaction_finished_event(start_time, end_time)
-          agent.stats_engine.end_transaction
         end
       end
 
@@ -221,7 +367,7 @@ module NewRelic
       # values and sampler can't be successfully modified from this event.
       def send_transaction_finished_event(start_time, end_time)
         payload = {
-          :name             => @name,
+          :name             => @frozen_name,
           :type             => @type,
           :start_timestamp  => start_time.to_f,
           :duration         => end_time.to_f - start_time.to_f,
@@ -248,14 +394,18 @@ module NewRelic
         end
       end
 
+      def log_underflow
+        NewRelic::Agent.logger.error "Underflow in transaction: #{caller.join("\n   ")}"
+      end
+
       def merge_stats_hash
-        stats_hash.resolve_scopes!(@name)
+        stats_hash.resolve_scopes!(best_name)
         NewRelic::Agent.instance.stats_engine.merge!(stats_hash)
       end
 
       def record_exceptions
         @exceptions.each do |exception, options|
-          options[:metric] = @name
+          options[:metric] = best_name
           agent.error_collector.notice_error(exception, options)
         end
       end
@@ -281,10 +431,10 @@ module NewRelic
       end
 
       def self.extract_request_options(options)
-        request = options.delete(:request)
-        if request
-          options[:referer] = referer_from_request(request)
-          options[:uri] = uri_from_request(request)
+        req = options.delete(:request)
+        if req
+          options[:referer] = referer_from_request(req)
+          options[:uri] = uri_from_request(req)
         end
         options
       end
@@ -292,12 +442,12 @@ module NewRelic
       # 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.transaction
+        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.name
+          options[:metric] = finished_txn.best_name
         end
         options
       end
@@ -333,17 +483,18 @@ module NewRelic
       def record_apdex(end_time=Time.now, is_error=nil)
         return unless recording_web_transaction? && NewRelic::Agent.is_execution_traced?
 
-        freeze_name
-        action_duration = end_time - start_time
-        total_duration  = end_time - apdex_start
-        is_error = is_error.nil? ? !exceptions.empty? : is_error
+        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
 
-        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)
+          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(@name.gsub(/^[^\/]+\//, 'Apdex/'))
-        @stats_hash.record(txn_apdex_metric, apdex_bucket_txn, 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)
+        end
       end
 
       def apdex_t
@@ -352,7 +503,7 @@ module NewRelic
 
       def transaction_specific_apdex_t
         key = :web_transactions_apdex
-        Agent.config[key] && Agent.config[key][self.name]
+        Agent.config[key] && Agent.config[key][best_name]
       end
 
       # Yield to a block that is run with a database metric name context.  This means
@@ -412,22 +563,22 @@ module NewRelic
 
       # Make a safe attempt to get the referer from a request object, generally successful when
       # it's a Rack request.
-      def self.referer_from_request(request)
-        if request && request.respond_to?(:referer)
-          request.referer.to_s.split('?').first
+      def self.referer_from_request(req)
+        if req && req.respond_to?(:referer)
+          req.referer.to_s.split('?').first
         end
       end
 
       # Make a safe attempt to get the URI, without the host and query string.
-      def self.uri_from_request(request)
+      def self.uri_from_request(req)
         approximate_uri = case
-                          when request.respond_to?(:fullpath) then request.fullpath
-                          when request.respond_to?(:path) then request.path
-                          when request.respond_to?(:request_uri) then request.request_uri
-                          when request.respond_to?(:uri) then request.uri
-                          when request.respond_to?(:url) then request.url
+                          when req.respond_to?(:fullpath   ) then req.fullpath
+                          when req.respond_to?(:path       ) then req.path
+                          when req.respond_to?(:request_uri) then req.request_uri
+                          when req.respond_to?(:uri        ) then req.uri
+                          when req.respond_to?(:url        ) then req.url
                           end
-        return approximate_uri[%r{^(https?://.*?)?(/[^?]*)}, 2] || '/' if approximate_uri # '
+        return approximate_uri[%r{^(https?://.*?)?(/[^?]*)}, 2] || '/' if approximate_uri
       end
 
 
@@ -449,6 +600,25 @@ module NewRelic
         end
       end
 
+      def cpu_burn
+        normal_cpu_burn || jruby_cpu_burn
+      end
+
+      def normal_cpu_burn
+        return unless @process_cpu_start
+        process_cpu - @process_cpu_start
+      end
+
+      def jruby_cpu_burn
+        return unless @jruby_cpu_start
+        jruby_cpu_time - @jruby_cpu_start
+      end
+
+      def record_transaction_cpu
+        burn = cpu_burn
+        transaction_sampler.notice_transaction_cpu_time(burn) if burn
+      end
+
       private
 
       def process_cpu
@@ -457,7 +627,7 @@ module NewRelic
         p.stime + p.utime
       end
 
-      def jruby_cpu_time # :nodoc:
+      def jruby_cpu_time
         return nil unless @@java_classes_loaded
         threadMBean = ManagementFactory.getThreadMXBean()
         java_utime = threadMBean.getCurrentThreadUserTime()  # ns