newrelic_rpm 3.6.6.147 → 3.6.7.152

data/lib/new_relic/agent/stats_engine.rb

@@ -18,7 +18,7 @@ module NewRelic
 
       def initialize
         # Makes the unit tests happy
-        Thread::current[:newrelic_scope_stack] = nil
+        NewRelic::Agent::TransactionState.get.clear_stats_scope_stack
         @stats_lock = Mutex.new
         @stats_hash = StatsHash.new
       end

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

@@ -57,7 +57,7 @@ module NewRelic
           end
 
           def scope_stack
-            Thread::current[:newrelic_scope_stack] ||= []
+            NewRelic::Agent::TransactionState.get.stats_scope_stack
           end
         end
 

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

@@ -59,10 +59,9 @@ module NewRelic
           get_stats(metric_name, false)
         end
 
-        # If use_scope is true, two chained metrics are created, one with scope and one without
         # If scoped_metric_only is true, only a scoped metric is created (used by rendering metrics which by definition are per controller only)
-        def get_stats(metric_name, use_scope = true, scoped_metric_only = false, scope = nil)
-          scope ||= scope_name if use_scope
+        # Leaving second, unused parameter for compatibility
+        def get_stats(metric_name, _ = true, scoped_metric_only = false, scope = nil)
           stats = nil
           with_stats_lock do
             if scoped_metric_only

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

@@ -29,8 +29,6 @@ module Agent
         def end_transaction; end
         def push_scope(*args); end
         def transaction_sampler=(*args); end
-        def scope_name=(*args); end
-        def scope_name; end
         def pop_scope(*args); end
       end
 
@@ -85,23 +83,6 @@ module Agent
         NewRelic::Agent.logger.warn("NewRelic::Agent::StatsEngine#transaction_sampler is deprecated")
       end
 
-      # set the name of the transaction for the current thread, which will be used
-      # to define the scope of all traced methods called on this thread until the
-      # scope stack is empty.
-      #
-      # currently the transaction name is the name of the controller action that
-      # is invoked via the dispatcher, but conceivably we could use other transaction
-      # names in the future if the traced application does more than service http request
-      # via controller actions
-      def scope_name=(transaction)
-        Thread::current[:newrelic_scope_name] = transaction
-      end
-
-      # Returns the current scope name from the thread local
-      def scope_name
-        Thread::current[:newrelic_scope_name]
-      end
-
       # Start a new transaction, unless one is already in progress
       def start_transaction
         NewRelic::Agent.instance.events.notify(:start_transaction)
@@ -115,8 +96,7 @@ module Agent
         stack = scope_stack
 
         if stack && stack.empty?
-          Thread::current[:newrelic_scope_stack] = nil
-          Thread::current[:newrelic_scope_name] = nil
+          NewRelic::Agent::TransactionState.get.clear_stats_scope_stack
         end
       end
 
@@ -126,7 +106,7 @@ module Agent
 
       # Returns the current scope stack, memoized to a thread local variable
       def scope_stack
-        Thread::current[:newrelic_scope_stack] ||= []
+        NewRelic::Agent::TransactionState.get.stats_scope_stack
       end
     end
   end

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

@@ -0,0 +1,41 @@
+# 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
+    module Threading
+
+      class AgentThread < ::Thread
+        def initialize(label)
+          ::NewRelic::Agent.logger.debug("Creating New Relic thread: #{label}")
+          self[:newrelic_label] = label
+          super
+        end
+
+        def self.bucket_thread(thread, profile_agent_code)
+          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
+          end
+        end
+
+        def self.scrub_backtrace(thread, profile_agent_code)
+          begin
+            bt = thread.backtrace
+          rescue Exception => e
+            ::NewRelic::Agent.logger.debug("Failed to backtrace #{thread.inspect}: #{e.class.name}: #{e.to_s}")
+          end
+          return nil unless bt
+          profile_agent_code ? bt : bt.select { |t| t !~ /\/newrelic_rpm-\d/ }
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+# 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
+    module Threading
+
+      class BacktraceNode
+        attr_reader :file, :method, :line_no, :children
+        attr_accessor :runnable_count, :to_prune, :depth
+
+        def initialize(line, parent=nil)
+          line =~ /(.*)\:(\d+)\:in `(.*)'/
+            @file = $1
+          @method = $3
+          @line_no = $2.to_i
+          @children = []
+          @runnable_count = 0
+          @to_prune = false
+          @depth = 0
+
+          parent.add_child(self) if parent
+        end
+
+        def ==(other)
+          @file == other.file &&
+            @method == other.method &&
+            @line_no == other.line_no
+        end
+
+        def total_count
+          @runnable_count
+        end
+
+        # Descending order on count, ascending on depth of nodes
+        def order_for_pruning(y)
+          [-runnable_count, depth] <=> [-y.runnable_count, y.depth]
+        end
+
+        include NewRelic::Coerce
+
+        def to_array
+          [[
+            string(@file),
+            string(@method),
+            int(@line_no)
+          ],
+            int(@runnable_count),
+            0,
+            @children.map {|c| c.to_array}]
+        end
+
+        def add_child(child)
+          child.depth = @depth + 1
+          @children << child unless @children.include? child
+        end
+
+        def prune!
+          BacktraceNode.prune!(@children)
+        end
+
+        def self.prune!(kids)
+          kids.delete_if { |child| child.to_prune }
+          kids.each { |child| child.prune! }
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,172 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require 'new_relic/agent/worker_loop'
+require 'new_relic/agent/threading/backtrace_node'
+
+# Intent is for this to be a data structure for representing a thread profile
+# TODO: Get rid of the running/sampling in this class, externalize it elsewhere
+
+module NewRelic
+  module Agent
+    module Threading
+
+      class ThreadProfile
+
+        attr_reader :profile_id,
+          :traces,
+          :profile_agent_code,
+          :interval, :duration,
+          :poll_count, :sample_count,
+          :start_time, :stop_time
+
+        def initialize(agent_command)
+          arguments = agent_command.arguments
+          @profile_id = arguments.fetch('profile_id', -1)
+          @profile_agent_code = arguments.fetch('profile_agent_code', true)
+
+          @duration = arguments.fetch('duration', 120)
+          @worker_loop = NewRelic::Agent::WorkerLoop.new(:duration => duration)
+          @interval = arguments.fetch('sample_period', 0.1)
+          @finished = false
+
+          @traces = {
+            :agent => [],
+            :background => [],
+            :other => [],
+            :request => []
+          }
+          @flattened_nodes = []
+
+          @poll_count = 0
+          @sample_count = 0
+          @failure_count = 0
+        end
+
+        def run
+          NewRelic::Agent.logger.debug("Starting thread profile. profile_id=#{profile_id}, duration=#{duration}")
+
+          Threading::AgentThread.new('Thread Profiler') do
+            @start_time = now_in_millis
+
+            @worker_loop.run(@interval) do
+              NewRelic::Agent.instance.stats_engine.
+                record_supportability_metric_timed("ThreadProfiler/PollingTime") do
+
+                @poll_count += 1
+                Threading::AgentThread.list.each do |t|
+                  bucket = Threading::AgentThread.bucket_thread(t, @profile_agent_code)
+                  if bucket != :ignore
+                    backtrace = Threading::AgentThread.scrub_backtrace(t, @profile_agent_code)
+                    if backtrace.nil?
+                      @failure_count += 1
+                    else
+                      @sample_count += 1
+                      aggregate(backtrace, @traces[bucket])
+                    end
+                  end
+                end
+                end
+            end
+
+            mark_done
+            NewRelic::Agent.logger.debug("Finished thread profile. #{@sample_count} backtraces, #{@failure_count} failures. Will send with next harvest.")
+            NewRelic::Agent.instance.stats_engine.
+              record_supportability_metric_count("ThreadProfiler/BacktraceFailures", @failure_count)
+          end
+        end
+
+        def stop
+          @worker_loop.stop
+          mark_done
+          NewRelic::Agent.logger.debug("Stopping thread profile.")
+        end
+
+        def aggregate(trace, trees=@traces[:request], parent=nil)
+          return nil if trace.nil? || trace.empty?
+          node = Threading::BacktraceNode.new(trace.last)
+          existing = trees.find {|n| n == node}
+
+          if existing.nil?
+            existing = node
+            @flattened_nodes << node
+          end
+
+          if parent
+            parent.add_child(node)
+          else
+            trees << node unless trees.include? node
+          end
+
+          existing.runnable_count += 1
+          aggregate(trace[0..-2], existing.children, existing)
+
+          existing
+        end
+
+        def prune!(count_to_keep)
+          @flattened_nodes.sort!(&:order_for_pruning)
+
+          NewRelic::Agent.instance.stats_engine.
+            record_supportability_metric_count("ThreadProfiler/NodeCount", @flattened_nodes.size)
+
+          mark_for_pruning(@flattened_nodes, count_to_keep)
+
+          traces.each { |_, nodes| Threading::BacktraceNode.prune!(nodes) }
+        end
+
+        THREAD_PROFILER_NODES = 20_000
+
+        include NewRelic::Coerce
+
+        def to_collector_array(encoder)
+          prune!(THREAD_PROFILER_NODES)
+
+          traces = {
+            "OTHER" => @traces[:other].map{|t| t.to_array },
+            "REQUEST" => @traces[:request].map{|t| t.to_array },
+            "AGENT" => @traces[:agent].map{|t| t.to_array },
+            "BACKGROUND" => @traces[:background].map{|t| t.to_array }
+          }
+
+          [[
+            int(@profile_id),
+            float(@start_time),
+            float(@stop_time),
+            int(@poll_count),
+            string(encoder.encode(traces)),
+            int(@sample_count),
+            0
+          ]]
+        end
+
+        def now_in_millis
+          Time.now.to_f * 1_000
+        end
+
+        def finished?
+          @finished
+        end
+
+        def mark_done
+          @finished = true
+          @stop_time = now_in_millis
+        end
+
+        def mark_for_pruning(nodes, count_to_keep)
+          to_prune = nodes[count_to_keep..-1] || []
+          to_prune.each { |n| n.to_prune = true }
+        end
+
+        def self.parse_backtrace(trace)
+          trace.map do |line|
+            line =~ /(.*)\:(\d+)\:in `(.*)'/
+              { :method => $3, :line_no => $2.to_i, :file => $1 }
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/new_relic/agent/transaction.rb

@@ -3,6 +3,7 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require 'new_relic/agent/transaction/pop'
+require 'new_relic/agent/transaction_timings'
 
 # A struct holding the information required to measure a controller
 # action.  This is put on the thread local.  Handles the issue of
@@ -30,7 +31,6 @@ module NewRelic
       # as a Rack::Request or an ActionController::AbstractRequest.
       attr_accessor :request
 
-
       # Return the currently active transaction, or nil.
       def self.current
         self.stack.last
@@ -54,7 +54,7 @@ module NewRelic
       end
 
       def self.stack
-        Thread.current[:newrelic_transaction] ||= []
+        TransactionState.get.current_transaction_stack
       end
 
       def self.in_transaction?
@@ -104,7 +104,11 @@ module NewRelic
         @request = options[:request]
         @exceptions = {}
         @stats_hash = StatsHash.new
-        TransactionInfo.get.transaction = self
+        TransactionState.get.transaction = self
+      end
+
+      def noticed_error_ids
+        @noticed_error_ids ||= []
       end
 
       def name=(name)
@@ -290,7 +294,6 @@ module NewRelic
         return unless recording_web_transaction? && NewRelic::Agent.is_execution_traced?
 
         freeze_name
-        apdex_t = TransactionInfo.get.apdex_t
         action_duration = end_time - start_time
         total_duration  = end_time - apdex_start
         is_error = is_error.nil? ? !exceptions.empty? : is_error
@@ -303,6 +306,15 @@ module NewRelic
         @stats_hash.record(txn_apdex_metric, apdex_bucket_txn, apdex_t)
       end
 
+      def apdex_t
+        transaction_specific_apdex_t || Agent.config[:apdex_t]
+      end
+
+      def transaction_specific_apdex_t
+        key = :web_transactions_apdex
+        Agent.config[key] && Agent.config[key][self.name]
+      end
+
       # Yield to a block that is run with a database metric name context.  This means
       # the Database instrumentation will use this for the metric name if it does not
       # otherwise know about a model.  This is re-entrant.

data/lib/new_relic/agent/transaction_sample_builder.rb

@@ -110,13 +110,23 @@ module NewRelic
         @sample.params[:custom_params] ||= {}
         @sample.params[:custom_params].merge!(normalize_params(custom_params))
 
-        txn_info = NewRelic::Agent::TransactionInfo.get
-        @sample.force_persist = txn_info.force_persist_sample?(sample)
-        @sample.threshold = txn_info.transaction_trace_threshold
+        @sample.force_persist = sample.force_persist_sample?
+        @sample.threshold = transaction_trace_threshold
         @sample.freeze
         @current_segment = nil
       end
 
+      TT_THRESHOLD_KEY = :'transaction_tracer.transaction_threshold'
+
+      def transaction_trace_threshold
+        source_class = Agent.config.source(TT_THRESHOLD_KEY).class
+        if source_class == Configuration::DefaultSource && TransactionState.get.transaction
+          TransactionState.get.transaction.apdex_t * 4
+        else
+          Agent.config[TT_THRESHOLD_KEY]
+        end
+      end
+
       def scope_depth
         depth = -1        # have to account for the root
         current = @current_segment