newrelic_rpm 3.6.7.159 → 3.6.8.164

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

@@ -2,11 +2,11 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
+require 'set'
 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
+# Data structure for representing a thread profile
 
 module NewRelic
   module Agent
@@ -14,156 +14,117 @@ module NewRelic
 
       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)
+        attr_reader :profile_id, :traces, :sample_period,
+          :duration, :poll_count, :backtrace_count, :failure_count,
+          :created_at, :xray_id, :command_arguments, :profile_agent_code
+        attr_accessor :finished_at
+
+        def initialize(command_arguments={})
+          @command_arguments  = command_arguments
+          @profile_id         = command_arguments.fetch('profile_id', -1)
+          @duration           = command_arguments.fetch('duration', 120)
+          @sample_period      = command_arguments.fetch('sample_period', 0.1)
+          @profile_agent_code = command_arguments.fetch('profile_agent_code', false)
+          @xray_id            = command_arguments.fetch('x_ray_id', nil)
           @finished = false
 
           @traces = {
-            :agent => [],
-            :background => [],
-            :other => [],
-            :request => []
+            :agent      => BacktraceNode.new(nil),
+            :background => BacktraceNode.new(nil),
+            :other      => BacktraceNode.new(nil),
+            :request    => BacktraceNode.new(nil)
           }
-          @flattened_nodes = []
 
           @poll_count = 0
-          @sample_count = 0
+          @backtrace_count = 0
           @failure_count = 0
+          @unique_threads = []
+
+          @created_at = Time.now
         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
+        def requested_period
+          @sample_period
         end
 
-        def stop
-          @worker_loop.stop
-          mark_done
-          NewRelic::Agent.logger.debug("Stopping thread profile.")
+        def increment_poll_count
+          @poll_count += 1
         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}
+        def sample_count
+          xray? ? @backtrace_count : @poll_count
+        end
 
-          if existing.nil?
-            existing = node
-            @flattened_nodes << node
-          end
+        def xray?
+          !!@xray_id
+        end
 
-          if parent
-            parent.add_child(node)
-          else
-            trees << node unless trees.include? node
-          end
+        def empty?
+          @backtrace_count == 0
+        end
 
-          existing.runnable_count += 1
-          aggregate(trace[0..-2], existing.children, existing)
+        def unique_thread_count
+          return 0 if @unique_threads.nil?
+          @unique_threads.length
+        end
 
-          existing
+        def aggregate(backtrace, bucket, thread)
+          if backtrace.nil?
+            @failure_count += 1
+          else
+            @backtrace_count += 1
+            @traces[bucket].aggregate(backtrace)
+            @unique_threads << thread unless @unique_threads.include?(thread)
+          end
         end
 
-        def prune!(count_to_keep)
-          @flattened_nodes.sort!(&:order_for_pruning)
+        def truncate_to_node_count!(count_to_keep)
+          all_nodes = @traces.values.map { |n| n.flatten }.flatten
 
           NewRelic::Agent.instance.stats_engine.
-            record_supportability_metric_count("ThreadProfiler/NodeCount", @flattened_nodes.size)
+            record_supportability_metric_count("ThreadProfiler/NodeCount", all_nodes.size)
 
-          mark_for_pruning(@flattened_nodes, count_to_keep)
-
-          traces.each { |_, nodes| Threading::BacktraceNode.prune!(nodes) }
+          all_nodes.sort!
+          nodes_to_prune = Set.new(all_nodes[count_to_keep..-1] || [])
+          traces.values.each { |root| root.prune!(nodes_to_prune) }
         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 }
+        def generate_traces
+          truncate_to_node_count!(THREAD_PROFILER_NODES)
+          {
+            "OTHER" => @traces[:other].to_array,
+            "REQUEST" => @traces[:request].to_array,
+            "AGENT" => @traces[:agent].to_array,
+            "BACKGROUND" => @traces[:background].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
+        def to_collector_array(encoder)
+          result = [
+            int(self.profile_id),
+            float(self.created_at),
+            float(self.finished_at),
+            int(self.sample_count),
+            string(encoder.encode(generate_traces)),
+            int(self.unique_thread_count),
+            0 # runnable thread count, which we don't track
+          ]
+          result << int(@xray_id) if xray?
+          result
         end
 
-        def mark_done
-          @finished = true
-          @stop_time = now_in_millis
-        end
+        def to_log_description
+          id = if xray?
+                 "@xray_id: #{xray_id}"
+               else
+                 "@profile_id: #{profile_id}"
+               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
+          "#<ThreadProfile:#{object_id} #{id} @command_arguments=#{@command_arguments.inspect}>"
         end
 
       end

data/lib/new_relic/agent/transaction/developer_mode_sample_buffer.rb

@@ -0,0 +1,56 @@
+# 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/transaction/transaction_sample_buffer'
+
+module NewRelic
+  module Agent
+    class Transaction
+      class DeveloperModeSampleBuffer < TransactionSampleBuffer
+
+        MAX_SAMPLES = 100
+
+        def max_samples
+          MAX_SAMPLES
+        end
+
+        def harvest_samples
+          NO_SAMPLES
+        end
+
+        def enabled?
+          Agent.config[:developer_mode]
+        end
+
+        # Truncate to the last max_samples we've received
+        def truncate_samples
+          @samples = @samples.last(max_samples)
+        end
+
+        # We don't hold onto previously trapped transactions on harvest
+        # We've already got all the traces we want, thank you!
+        def store_previous(*)
+        end
+
+        # Captures the stack trace for a segment
+        # This is expensive and not for production mode
+        def visit_segment(segment)
+          return unless enabled? && segment
+
+          trace = strip_newrelic_frames(caller)
+          trace = trace.first(40) if trace.length > 40
+          segment[:backtrace] = trace
+        end
+
+        def strip_newrelic_frames(trace)
+          while trace.first =~/\/lib\/new_relic\/agent\//
+            trace.shift
+          end
+          trace
+        end
+
+      end
+    end
+  end
+end

data/lib/new_relic/agent/transaction/force_persist_sample_buffer.rb

@@ -0,0 +1,25 @@
+# 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/transaction/transaction_sample_buffer'
+
+module NewRelic
+  module Agent
+    class Transaction
+      class ForcePersistSampleBuffer < TransactionSampleBuffer
+
+        MAX_SAMPLES = 10
+
+        def max_samples
+          MAX_SAMPLES
+        end
+
+        def allow_sample?(sample)
+          sample.force_persist
+        end
+
+      end
+    end
+  end
+end

data/lib/new_relic/agent/transaction/slowest_sample_buffer.rb

@@ -0,0 +1,25 @@
+# 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/transaction/transaction_sample_buffer'
+
+module NewRelic
+  module Agent
+    class Transaction
+      class SlowestSampleBuffer < TransactionSampleBuffer
+
+        MAX_SAMPLES = 1
+
+        def max_samples
+          MAX_SAMPLES
+        end
+
+        def allow_sample?(sample)
+          sample.threshold && sample.duration >= sample.threshold
+        end
+
+      end
+    end
+  end
+end

data/lib/new_relic/agent/transaction/transaction_sample_buffer.rb

@@ -0,0 +1,86 @@
+# 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 Transaction
+      class TransactionSampleBuffer
+        attr_reader :samples
+
+        NO_SAMPLES = [].freeze
+
+        def initialize
+          @samples = []
+        end
+
+        def enabled?
+          true
+        end
+
+        def reset!
+          @samples = []
+        end
+
+        def harvest_samples
+          @samples
+        ensure
+          reset!
+        end
+
+        def allow_sample?(sample)
+          true
+        end
+
+        def store(sample)
+          return unless enabled?
+          if allow_sample?(sample)
+            add_sample(sample)
+            truncate_samples_if_needed
+          end
+        end
+
+        def store_previous(previous_samples)
+          return unless enabled?
+          previous_samples.each do |sample|
+            add_sample(sample) if allow_sample?(sample)
+          end
+          truncate_samples_if_needed
+        end
+
+        def truncate_samples_if_needed
+          truncate_samples if full?
+        end
+
+        def full?
+          @samples.length >= max_samples
+        end
+
+        # Our default truncation strategy is to keep max_samples worth of the
+        # longest samples. Override this method for alternate behavior.
+        #
+        # This doesn't use the more convenient #last and #sort_by to avoid
+        # additional array allocations (and abundant alliteration)
+        def truncate_samples
+          @samples.sort!{|a,b| a.duration <=> b.duration}
+          @samples.slice!(0..-(max_samples + 1))
+        end
+
+        # When pushing a scope different sample buffers potentially want to
+        # know about what's happening to annotate the incoming segments
+        def visit_segment(*)
+          # no-op
+        end
+
+        private
+
+        # If a buffer needs to modify an added sample, override this method.
+        # Bounds checking, allowing samples and truncation belongs elsewhere.
+        def add_sample(sample)
+          @samples << sample
+        end
+
+      end
+    end
+  end
+end

data/lib/new_relic/agent/transaction/xray_sample_buffer.rb

@@ -0,0 +1,64 @@
+# 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/transaction/transaction_sample_buffer'
+
+module NewRelic
+  module Agent
+    class Transaction
+      class XraySampleBuffer < TransactionSampleBuffer
+
+        attr_writer :xray_session_collection
+
+        def initialize
+          super
+
+          # Memoize the config setting since this happens per request
+          @enabled = NewRelic::Agent.config[:'xray_session.allow_traces']
+          NewRelic::Agent.config.register_callback(:'xray_session.allow_traces') do |new_value|
+            @enabled = new_value
+          end
+
+          @max_samples = NewRelic::Agent.config[:'xray_session.max_samples']
+          NewRelic::Agent.config.register_callback(:'xray_session.max_samples') do |new_value|
+            @max_samples = new_value
+          end
+        end
+
+        def xray_session_collection
+          @xray_session_collection ||= NewRelic::Agent.instance.agent_command_router.xray_session_collection
+        end
+
+        def max_samples
+          @max_samples
+        end
+
+        def truncate_samples
+          # First in wins, so stop on allow_sample? instead of truncating
+        end
+
+        def allow_sample?(sample)
+          !full? && !lookup_session_id(sample).nil?
+        end
+
+        def enabled?
+          @enabled
+        end
+
+
+        private
+
+        def add_sample(sample)
+          super(sample)
+          sample.xray_session_id = lookup_session_id(sample)
+        end
+
+        def lookup_session_id(sample)
+          xray_session_collection.session_id_for_transaction_name(sample.transaction_name)
+        end
+
+      end
+    end
+  end
+end