newrelic_rpm 3.8.1.221 → 3.9.0.229

data/lib/new_relic/agent/transaction_metrics.rb

@@ -0,0 +1,57 @@
+# 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.
+
+# This class represents a set of metrics that were recorded during a single
+# transaction. Since the name of the transaction is not known until its end, we
+# don't save explicit scopes with these metrics, we just keep separate
+# collections of scoped and unscoped metrics.
+
+module NewRelic
+  module Agent
+    class TransactionMetrics
+      DEFAULT_PROC = Proc.new { |hash, name| hash[name] = NewRelic::Agent::Stats.new }
+
+      def initialize
+        @unscoped = Hash.new(&DEFAULT_PROC)
+        @scoped   = Hash.new(&DEFAULT_PROC)
+      end
+
+      def record_scoped(names, value=nil, aux=nil, &blk)
+        _record_metrics(names, value, aux, @scoped, &blk)
+      end
+
+      def record_unscoped(names, value=nil, aux=nil, &blk)
+        _record_metrics(names, value, aux, @unscoped, &blk)
+      end
+
+      def has_key?(key)
+        @unscoped.has_key?(key)
+      end
+
+      def [](key)
+        @unscoped[key]
+      end
+
+      def each_unscoped
+        @unscoped.each { |name, stats| yield name, stats }
+      end
+
+      def each_scoped
+        @scoped.each { |name, stats| yield name, stats }
+      end
+
+      def _record_metrics(names, value, aux, target, &blk)
+        # This looks dumb, but we're avoiding an extra Array allocation.
+        case names
+        when Array
+          names.each do |name|
+            target[name].record(value, aux, &blk)
+          end
+        else
+          target[names].record(value, aux, &blk)
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/transaction_sample_builder.rb

@@ -118,10 +118,11 @@ module NewRelic
 
       TT_THRESHOLD_KEY = :'transaction_tracer.transaction_threshold'
 
-      def transaction_trace_threshold
+      def transaction_trace_threshold #THREAD_LOCAL_ACCESS
+        state = TransactionState.tl_get
         source_class = Agent.config.source(TT_THRESHOLD_KEY).class
-        if source_class == Configuration::DefaultSource && TransactionState.get.current_transaction
-          TransactionState.get.current_transaction.apdex_t * 4
+        if source_class == Configuration::DefaultSource && state.current_transaction
+          state.current_transaction.apdex_t * 4
         else
           Agent.config[TT_THRESHOLD_KEY]
         end
@@ -139,15 +140,17 @@ module NewRelic
         depth
       end
 
-      def set_transaction_info(uri, params)
-        if Agent.config[:capture_params]
-          params = normalize_params params
+      def set_transaction_uri(uri)
+        @sample.params[:uri] ||= uri
+      end
 
+      def set_request_params(params)
+        if Agent.config[:capture_params]
+          params = normalize_params(params)
           @sample.params[:request_params].merge!(params)
           @sample.params[:request_params].delete :controller
           @sample.params[:request_params].delete :action
         end
-        @sample.params[:uri] ||= uri || params[:uri]
       end
 
       def set_transaction_name(name)

data/lib/new_relic/agent/transaction_sampler.rb

@@ -13,8 +13,14 @@ require 'new_relic/agent/transaction/xray_sample_buffer'
 module NewRelic
   module Agent
 
-    # This class contains the logic of sampling a transaction -
-    # creation and modification of transaction samples
+    # This class contains the logic for recording and storing transaction
+    # traces (sometimes referred to as 'transaction samples').
+    #
+    # A transaction trace is a detailed timeline of the events that happened
+    # during the processing of a single transaction, including database calls,
+    # template rendering calls, and other instrumented method calls.
+    #
+    # @api public
     class TransactionSampler
 
       # Module defining methods stubbed out when the agent is disabled
@@ -62,10 +68,11 @@ module NewRelic
         Agent.config[:'transaction_tracer.enabled'] || Agent.config[:developer_mode]
       end
 
-      def on_start_transaction(start_time, uri=nil, params={})
+      def on_start_transaction(state, start_time, uri=nil)
         if enabled?
-          start_builder(start_time.to_f)
-          builder.set_transaction_info(uri, params) if builder
+          start_builder(state, start_time.to_f)
+          builder = state.transaction_sample_builder
+          builder.set_transaction_uri(uri) if builder
         end
       end
 
@@ -74,16 +81,20 @@ module NewRelic
       #
       # Note that in developer mode, this captures a stacktrace for
       # the beginning of each segment, which can be fairly slow
-      def notice_push_frame(time=Time.now)
+      def notice_push_frame(state, time=Time.now)
+        builder = state.transaction_sample_builder
         return unless builder
 
         segment = builder.trace_entry(time.to_f)
-        @sample_buffers.each { |sample_buffer| sample_buffer.visit_segment(segment) }
-        return segment
+        if @dev_mode_sample_buffer
+          @dev_mode_sample_buffer.visit_segment(segment)
+        end
+        segment
       end
 
       # Informs the transaction sample builder about the end of a traced frame
-      def notice_pop_frame(frame, time = Time.now)
+      def notice_pop_frame(state, frame, time = Time.now)
+        builder = state.transaction_sample_builder
         return unless builder
         raise "finished already???" if builder.sample.finished
         builder.trace_exit(frame, time.to_f)
@@ -104,15 +115,16 @@ module NewRelic
       #
       # It sets various instance variables to the finished sample,
       # depending on which settings are active. See `store_sample`
-      def on_finishing_transaction(txn, time=Time.now, gc_time=nil)
-        last_builder = builder
-        last_builder.set_transaction_name(txn.best_name) if enabled? && last_builder
+      def on_finishing_transaction(state, txn, time=Time.now, gc_time=nil)
+        last_builder = state.transaction_sample_builder
+        return unless last_builder && enabled?
 
-        return unless last_builder
+        state.transaction_sample_builder = nil
+        return if last_builder.ignored?
 
+        last_builder.set_request_params(txn.filtered_params)
+        last_builder.set_transaction_name(txn.best_name)
         last_builder.finish_trace(time.to_f, custom_parameters_from_transaction(txn))
-        clear_builder
-        return if last_builder.ignored?
 
         @samples_lock.synchronize do
           @last_sample = last_builder.sample
@@ -133,12 +145,14 @@ module NewRelic
       # creating one. Only causes the sample to be ignored upon end of
       # the transaction, and does not change the metrics gathered
       # outside of the sampler
-      def ignore_transaction
+      def ignore_transaction(state)
+        builder = state.transaction_sample_builder
         builder.ignore_transaction if builder
       end
 
       # Sets the CPU time used by a transaction, delegates to the builder
-      def notice_transaction_cpu_time(cpu_time)
+      def notice_transaction_cpu_time(state, cpu_time)
+        builder = state.transaction_sample_builder
         builder.set_transaction_cpu_time(cpu_time) if builder
       end
 
@@ -147,7 +161,7 @@ module NewRelic
       # active segment like a sql query, memcache key, or Net::HTTP uri
       #
       # duration is seconds, float value.
-      def notice_extra_data(message, duration, key)
+      def notice_extra_data(builder, message, duration, key)
         return unless builder
         segment = builder.current_segment
         if segment
@@ -182,14 +196,28 @@ module NewRelic
         end
       end
 
-      # some statements (particularly INSERTS with large BLOBS
-      # may be very large; we should trim them to a maximum usable length
-      # config is the driver configuration for the connection
-      # duration is seconds, float value.
-      def notice_sql(sql, config, duration, &explainer)
-        if NewRelic::Agent.is_sql_recorded?
+      # Attaches an SQL query on the current transaction trace segment.
+      #
+      # This method should be used only by gem authors wishing to extend
+      # the Ruby agent to instrument new database interfaces - it should
+      # generally not be called directly from application code.
+      #
+      # @param sql [String] the SQL query being recorded
+      # @param config [Object] the driver configuration for the connection
+      # @param duration [Float] number of seconds the query took to execute
+      # @param explainer [Proc] for internal use only - 3rd-party clients must
+      #                         not pass this parameter.
+      #
+      # @api public
+      #
+      def notice_sql(sql, config, duration, state=nil, &explainer) #THREAD_LOCAL_ACCESS sometimes
+        # some statements (particularly INSERTS with large BLOBS
+        # may be very large; we should trim them to a maximum usable length
+        state ||= TransactionState.tl_get
+        builder = state.transaction_sample_builder
+        if state.is_sql_recorded?
           statement = build_database_statement(sql, config, explainer)
-          notice_extra_data(statement, duration, :sql)
+          notice_extra_data(builder, statement, duration, :sql)
         end
       end
 
@@ -204,19 +232,34 @@ module NewRelic
         statement
       end
 
-      # Adds non-sql metadata to a segment - generally the memcached key
+      # Attaches an additional non-SQL query parameter to the current
+      # transaction trace segment.
       #
-      # duration is seconds, float value.
-      def notice_nosql(key, duration)
-        notice_extra_data(key, duration, :key)
+      # This may be used for recording a query against a key-value store like
+      # memcached or redis.
+      #
+      # This method should be used only by gem authors wishing to extend
+      # the Ruby agent to instrument uninstrumented key-value stores - it should
+      # generally not be called directly from application code.
+      #
+      # @param key [String] the name of the key that was queried
+      # @param duration [Float] number of seconds the query took to execute
+      #
+      # @api public
+      #
+      def notice_nosql(key, duration) #THREAD_LOCAL_ACCESS
+        builder = tl_builder
+        notice_extra_data(builder, key, duration, :key)
       end
 
-      def notice_nosql_statement(statement, duration)
-        notice_extra_data(statement, duration, :statement)
+      def notice_nosql_statement(statement, duration) #THREAD_LOCAL_ACCESS
+        builder = tl_builder
+        notice_extra_data(builder, statement, duration, :statement)
       end
 
       # Set parameters on the current segment.
-      def add_segment_parameters( params )
+      def add_segment_parameters(params) #THREAD_LOCAL_ACCESS
+        builder = tl_builder
         return unless builder
         params.each { |k,v| builder.current_segment[k] = v }
       end
@@ -283,25 +326,18 @@ module NewRelic
       # sample builder from the thread local, otherwise it generates a
       # new transaction sample builder with the stated time as a
       # starting point and saves it in the thread local variable
-      def start_builder(time=nil)
-        if !enabled? || !NewRelic::Agent.is_transaction_traced? || !NewRelic::Agent.is_execution_traced?
-          clear_builder
+      def start_builder(state, time=nil)
+        if !enabled? || !state.is_transaction_traced? || !state.is_execution_traced?
+          state.transaction_sample_builder = nil
         else
-          TransactionState.get.transaction_sample_builder ||= TransactionSampleBuilder.new(time)
+          state.transaction_sample_builder ||= TransactionSampleBuilder.new(time)
         end
       end
 
       # The current thread-local transaction sample builder
-      def builder
-        TransactionState.get.transaction_sample_builder
-      end
-
-      # Sets the thread local variable storing the transaction sample
-      # builder to nil to clear it
-      def clear_builder
-        TransactionState.get.transaction_sample_builder = nil
+      def tl_builder
+        TransactionState.tl_get.transaction_sample_builder
       end
-
     end
   end
 end

data/lib/new_relic/agent/transaction_state.rb

@@ -11,34 +11,31 @@ module NewRelic
     # This is THE location to store thread local information during a transaction
     # Need a new piece of data? Add a method here, NOT a new thread local variable.
     class TransactionState
-
-      def self.get
-        state_for(Thread.current)
+      def self.tl_get
+        tl_state_for(Thread.current)
       end
 
       # This method should only be used by TransactionState for access to the
       # current thread's state or to provide read-only accessors for other threads
       #
       # If ever exposed, this requires additional synchronization
-      def self.state_for(thread)
-        thread[:newrelic_transaction_state] ||= TransactionState.new
-      end
-      private_class_method :state_for
+      def self.tl_state_for(thread)
+        state = thread[:newrelic_transaction_state]
 
-      def self.clear
-        Thread.current[:newrelic_transaction_state] = nil
-      end
+        if state.nil?
+          state = TransactionState.new
+          thread[:newrelic_transaction_state] = state
+        end
 
-      # This starts the timer for the transaction.
-      def self.reset
-        self.get.reset
+        state
       end
 
-      def self.request=(request)
-        self.get.request = request
+      def self.tl_clear_for_testing
+        Thread.current[:newrelic_transaction_state] = nil
       end
 
       def initialize
+        @untraced = []
         @traced_method_stack = TracedMethodStack.new
         @current_transaction = nil
       end
@@ -48,18 +45,27 @@ module NewRelic
         @request_token = BrowserToken.get_token(request)
       end
 
-      def reset
-        # We almost always want to use the transaction time, but in case it's
-        # not available, we track the last reset. No accessor, as only the
-        # TransactionState class should use it.
-        @last_reset_time = Time.now
-        @most_recent_transaction = nil
+      # This starts the timer for the transaction.
+      def reset(transaction=nil)
+        # We purposefully don't reset @untraced, @record_tt and @record_sql
+        # since those are managed by NewRelic::Agent.disable_* calls explicitly
+        # and (more importantly) outside the scope of a transaction
+
         @timings = nil
         @request = nil
+        @current_transaction = transaction
+
+        @traced_method_stack.clear
+
         @request_token = nil
-        @request_ignore_enduser = false
         @is_cross_app_caller = false
+        @client_cross_app_id = nil
         @referring_transaction_info = nil
+
+        @transaction_sample_builder = nil
+        @sql_sampler_transaction_data = nil
+
+        @busy_entries = 0
       end
 
       def timings
@@ -85,11 +91,11 @@ module NewRelic
 
       # Request data
       attr_reader :request
-      attr_accessor :request_token, :request_ignore_enduser
+      attr_accessor :request_token
 
       def request_guid
-        return nil unless most_recent_transaction
-        most_recent_transaction.guid
+        return nil unless current_transaction
+        current_transaction.guid
       end
 
       def request_guid_to_include
@@ -98,39 +104,23 @@ module NewRelic
       end
 
       def include_guid?
-        request_token && timings.app_time_in_seconds > most_recent_transaction.apdex_t
+        request_token && timings.app_time_in_seconds > current_transaction.apdex_t
       end
 
       # Current transaction stack and sample building
-      attr_accessor :most_recent_transaction, :transaction_sample_builder,
-                    :current_transaction
+      attr_reader   :current_transaction
+      attr_accessor :transaction_sample_builder
 
       def transaction_start_time
-        if most_recent_transaction.nil?
-          @last_reset_time
-        else
-          most_recent_transaction.start_time
-        end
+        current_transaction.start_time if current_transaction
       end
 
       def transaction_queue_time
-        most_recent_transaction.nil? ? 0.0 : most_recent_transaction.queue_time
+        current_transaction.nil? ? 0.0 : current_transaction.queue_time
       end
 
       def transaction_name
-        most_recent_transaction.nil? ? nil : most_recent_transaction.best_name
-      end
-
-      def transaction_noticed_error_ids
-        most_recent_transaction.nil? ? [] : most_recent_transaction.noticed_error_ids
-      end
-
-      def self.in_background_transaction?(thread)
-        state_for(thread).in_background_transaction?
-      end
-
-      def self.in_request_transaction?(thread)
-        state_for(thread).in_request_transaction?
+        current_transaction.nil? ? nil : current_transaction.best_name
       end
 
       def in_background_transaction?
@@ -145,7 +135,6 @@ module NewRelic
       attr_accessor :untraced
 
       def push_traced(should_trace)
-        @untraced ||= []
         @untraced << should_trace
       end
 
@@ -153,7 +142,7 @@ module NewRelic
         @untraced.pop if @untraced
       end
 
-      def is_traced?
+      def is_execution_traced?
         @untraced.nil? || @untraced.last != false
       end