sundawg_newrelic_rpm 3.5.8.1

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

@@ -0,0 +1,97 @@
+module NewRelic
+module Agent
+  class StatsEngine
+    module Shim # :nodoc:
+      def add_sampler(*args); end
+      def add_harvest_sampler(*args); end
+      def start_sampler_thread(*args); end
+    end
+    
+    # Contains statistics engine extensions to support the concept of samplers
+    module Samplers
+
+      # By default a sampler polls on harvest time, once a minute.  However you can
+      # override #use_harvest_sampler? to return false and it will sample
+      # every POLL_PERIOD seconds on a background thread.
+      POLL_PERIOD = 20
+      
+      # starts the sampler thread which runs periodically, rather than
+      # at harvest time. This is deprecated, and should not actually
+      # be used - mo threads mo problems
+      #
+      # returns unless there are actually periodic samplers to run
+      def start_sampler_thread
+
+        return if @sampler_thread && @sampler_thread.alive?
+
+        # start up a thread that will periodically poll for metric samples
+        return if periodic_samplers.empty?
+
+        @sampler_thread = NewRelic::Agent::AgentThread.new('Sampler Tasks') do
+          loop do
+            now = Time.now
+            begin
+              sleep POLL_PERIOD
+              poll periodic_samplers
+            ensure
+              NewRelic::Agent.instance.stats_engine \
+                .get_stats_no_scope('Supportability/Samplers') \
+                .record_data_point((Time.now - now).to_f)
+            end
+          end
+        end
+      end
+
+      private
+
+      def add_sampler_to(sampler_array, sampler)
+        raise "Sampler #{sampler.inspect} is already registered.  Don't call add_sampler directly anymore." if sampler_array.include?(sampler)
+        sampler_array << sampler
+        sampler.stats_engine = self
+      end
+
+      def log_added_sampler(type, sampler)
+        ::NewRelic::Agent.logger.debug "Adding #{type} sampler: #{sampler.id}"
+      end
+
+      public
+
+      # Add an instance of Sampler to be invoked about every 10 seconds on a background
+      # thread.
+      def add_sampler(sampler)
+        add_sampler_to(periodic_samplers, sampler)
+        log_added_sampler('periodic', sampler)
+      end
+
+      # Add a sampler to be invoked just before each harvest.
+      def add_harvest_sampler(sampler)
+        add_sampler_to(harvest_samplers, sampler)
+        log_added_sampler('harvest-time', sampler)
+      end
+
+      private
+
+      # Call poll on each of the samplers.  Remove
+      # the sampler if it raises.
+      def poll(samplers)
+        samplers.delete_if do |sampled_item|
+          begin
+            sampled_item.poll
+            false # it's okay.  don't delete it.
+          rescue => e
+            ::NewRelic::Agent.logger.warn "Removing #{sampled_item} from list", e
+            true # remove the sampler
+          end
+        end
+      end
+
+      def harvest_samplers
+        @harvest_samplers ||= []
+      end
+      def periodic_samplers
+        @periodic_samplers ||= []
+      end
+    end
+  end
+end
+end

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

@@ -0,0 +1,58 @@
+# A Hash-descended class for storing metric data in the NewRelic Agent.
+#
+# Keys are NewRelic::MetricSpec objects.
+# Values are NewRelic::Agent::Stats objects.
+#
+# Missing keys will be automatically created as empty NewRelic::Agent::Stats
+# instances, so use has_key? explicitly to check for key existence.
+#
+# This class makes no provisions for safe usage from multiple threads, such
+# measures should be externally provided.
+module NewRelic
+  module Agent
+    class StatsHash < ::Hash
+      def initialize
+        super { |hash, key| hash[key] = NewRelic::Agent::Stats.new }
+      end
+
+      def marshal_dump
+        Hash[self]
+      end
+
+      def marshal_load(hash)
+        self.merge!(hash)
+      end
+
+      def ==(other)
+        Hash[self] == Hash[other]
+      end
+
+      def record(metric_specs, value=nil)
+        Array(metric_specs).each do |metric_spec|
+          stats = self[metric_spec]
+          if block_given?
+            yield stats
+          else
+            case value
+            when Numeric
+              stats.record_data_point(value)
+            when NewRelic::Agent::Stats
+              stats.merge!(value)
+            end
+          end
+        end
+      end
+
+      def merge!(other)
+        other.each do |key,val|
+          if self.has_key?(key)
+            self[key].merge!(val)
+          else
+            self[key] = val
+          end
+        end
+        self
+      end
+    end
+  end
+end

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

@@ -0,0 +1,145 @@
+# -*- coding: utf-8 -*-
+module NewRelic
+module Agent
+  class StatsEngine
+    # A simple stack element that tracks the current name and length
+    # of the executing stack
+    class ScopeStackElement
+      attr_reader :deduct_call_time_from_parent
+      attr_accessor :name, :children_time
+      def initialize(name, deduct_call_time)
+        @name = name
+        @deduct_call_time_from_parent = deduct_call_time
+        @children_time = 0
+      end
+    end
+
+    # Handles pushing and popping elements onto an internal stack that
+    # tracks where time should be allocated in Transaction Traces
+    module Transactions
+
+      # Defines methods that stub out the stats engine methods
+      # when the agent is disabled
+      module Shim # :nodoc:
+        def start_transaction(*args); end
+        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
+
+      attr_reader :transaction_sampler
+
+      # add a new transaction sampler, unless we're currently in a
+      # transaction (then we fail)
+      def transaction_sampler= sampler
+        fail "Can't add a scope listener midflight in a transaction" if scope_stack.any?
+        @transaction_sampler = sampler
+      end
+
+      # removes a transaction sampler
+      def remove_transaction_sampler(l)
+        @transaction_sampler = nil
+      end
+
+      # Pushes a scope onto the transaction stack - this generates a
+      # TransactionSample::Segment at the end of transaction execution
+      def push_scope(metric, time = Time.now.to_f, deduct_call_time_from_parent = true)
+        stack = scope_stack
+        @transaction_sampler.notice_push_scope metric, time if sampler_enabled?
+        scope = ScopeStackElement.new(metric, deduct_call_time_from_parent)
+        stack.push scope
+        scope
+      end
+
+      # Pops a scope off the transaction stack - this updates the
+      # transaction sampler that we've finished execution of a traced method
+      def pop_scope(expected_scope, duration, time=Time.now.to_f)
+        stack = scope_stack
+        scope = stack.pop
+
+        if scope != expected_scope 
+            scope = expected_scope
+        end
+
+        if !stack.empty?
+          if scope.deduct_call_time_from_parent
+            stack.last.children_time += duration
+          else
+            stack.last.children_time += scope.children_time
+          end
+        end
+        @transaction_sampler.notice_pop_scope(scope.name, time) if sampler_enabled?
+        scope
+      end
+      
+      def sampler_enabled?
+        @transaction_sampler && Agent.config[:'transaction_tracer.enabled']
+      end
+      
+      # Rename the segment associated with the last pushed scope to +new_name+.
+      def rename_scope_segment( new_name )
+        self.peek_scope.name = new_name
+        @transaction_sampler.rename_scope_segment( new_name )
+      end
+      
+      # Returns the latest ScopeStackElement
+      def peek_scope
+        scope_stack.last
+      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(name = nil)
+        Thread::current[:newrelic_scope_stack] ||= []
+        self.scope_name = name if name
+        NewRelic::Agent.instance.events.notify(:start_transaction, name)
+        GCProfiler.init
+      end
+
+      # Try to clean up gracefully, otherwise we leave things hanging around on thread locals.
+      # If it looks like a transaction is still in progress, then maybe this is an inner transaction
+      # and is ignored.
+      #
+      def end_transaction
+        elapsed = GCProfiler.capture
+        if @transaction_sampler && @transaction_sampler.last_sample
+          @transaction_sampler.last_sample.params[:custom_params] ||= {}
+          @transaction_sampler.last_sample.params[:custom_params][:gc_time] = elapsed
+        end
+        stack = scope_stack
+
+        if stack && stack.empty?
+          Thread::current[:newrelic_scope_stack] = nil
+          Thread::current[:newrelic_scope_name] = nil
+        end
+      end
+
+      private
+
+      # Returns the current scope stack, memoized to a thread local variable
+      def scope_stack
+        Thread::current[:newrelic_scope_stack] ||= []
+      end
+    end
+  end
+end
+end

data/lib/new_relic/agent/thread.rb

@@ -0,0 +1,32 @@
+module NewRelic
+  module Agent
+
+    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)
+          return profile_agent_code ? :agent : :ignore
+        elsif !thread[:newrelic_metric_frame].nil?
+          thread[:newrelic_metric_frame].request.nil? ? :background : :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

data/lib/new_relic/agent/thread_profiler.rb

@@ -0,0 +1,319 @@
+require 'new_relic/agent/thread'
+require 'new_relic/agent/worker_loop'
+
+module NewRelic
+  module Agent
+
+    class ThreadProfiler
+
+      attr_reader :profile
+
+      def self.is_supported?
+        RUBY_VERSION >= "1.9.2"
+      end
+
+      def start(profile_id, duration, interval, profile_agent_code)
+        if !ThreadProfiler.is_supported?
+          ::NewRelic::Agent.logger.debug("Not starting thread profile as it isn't supported on this environment")
+          @profile = nil
+        else
+          ::NewRelic::Agent.logger.debug("Starting thread profile. profile_id=#{profile_id}, duration=#{duration}")
+          @profile = ThreadProfile.new(profile_id, duration, interval, profile_agent_code)
+          @profile.run
+        end
+      end
+
+      def stop(report_data)
+        @profile.stop unless @profile.nil?
+        @profile = nil if !report_data
+      end
+
+      def harvest
+        profile = @profile
+        @profile = nil
+        profile
+      end
+
+      def respond_to_commands(commands, &notify_results)
+        return if commands.empty? || commands.first.size < 2 
+
+        # Doesn't deal with multiple commands in the return set  as 
+        # we currently only have start/stop of thread profiling
+        command_id = commands.first[0]
+        command = commands.first[1]
+
+        name = command["name"]
+        arguments = command["arguments"]
+
+        if (ThreadProfiler.is_supported?)
+          case name
+            when "start_profiler"
+              start_unless_running_and_notify(command_id, arguments, &notify_results)
+
+            when "stop_profiler"
+              stop_and_notify(command_id, arguments, &notify_results)
+          end
+        else
+          msg = <<-EOF
+Thread profiling is only supported on 1.9.2 and greater versions of Ruby.
+We detected running agents capable of profiling, but the profile started with
+an agent running Ruby #{RUBY_VERSION}.
+
+Profiling again might select an appropriate agent, but we recommend running a
+consistent version of Ruby across your application for better results.
+EOF
+          ::NewRelic::Agent.logger.debug(msg)
+          notify_results.call(command_id, msg) if !notify_results.nil?
+        end
+      end
+
+      def running?
+        !@profile.nil?
+      end
+
+      def finished?
+        @profile && @profile.finished?
+      end
+
+      private
+
+      def start_unless_running_and_notify(command_id, arguments)
+        profile_id = arguments.fetch("profile_id", -1)
+        duration =   arguments.fetch("duration", 120)
+        interval =   arguments.fetch("sample_period", 0.1)
+        profile_agent_code = arguments.fetch("profile_agent_code", true)
+
+        if running?
+          msg = "Profile already in progress. Ignoring agent command to start another."
+          ::NewRelic::Agent.logger.debug(msg)
+          yield(command_id, msg) if block_given?
+        else
+          start(profile_id, duration, interval, profile_agent_code)
+          yield(command_id) if block_given?
+        end
+      end
+
+      def stop_and_notify(command_id, arguments)
+        report_data = arguments.fetch("report_data", true)
+        stop(report_data)
+        yield(command_id) if block_given?
+      end
+
+    end
+
+    class ThreadProfile
+
+      attr_reader :profile_id, 
+        :traces, 
+        :profile_agent_code, :interval, 
+        :poll_count, :sample_count, 
+        :start_time, :stop_time
+
+      def initialize(profile_id, duration, interval, profile_agent_code)
+        @profile_id = profile_id
+        @profile_agent_code = profile_agent_code
+
+        @worker_loop = NewRelic::Agent::WorkerLoop.new(:duration => duration)
+        @interval = interval
+        @finished = false
+
+        @traces = {
+          :agent => [],
+          :background => [],
+          :other => [],
+          :request => []
+        }
+        @flattened_nodes = []
+
+        @poll_count = 0
+        @sample_count = 0
+        @failure_count = 0
+      end
+
+      def run
+        AgentThread.new('Thread Profiler') do
+          @start_time = now_in_millis
+
+          @worker_loop.run(@interval) do
+            NewRelic::Agent.instance.stats_engine.
+              record_supportability_metrics_timed("ThreadProfiler/PollingTime") do
+
+              @poll_count += 1
+              AgentThread.list.each do |t|
+                bucket = AgentThread.bucket_thread(t, @profile_agent_code)
+                if bucket != :ignore
+                  backtrace = 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_metrics_count(@failure_count, "ThreadProfiler/BacktraceFailures")
+        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 = Node.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_metrics_count(@flattened_nodes.size, "ThreadProfiler/NodeCount")
+
+        mark_for_pruning(@flattened_nodes, count_to_keep)
+
+        traces.each { |_, nodes| Node.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.flattened_nodes(nodes)
+        nodes.map { |n| [n, flattened_nodes(n.children)] }.flatten
+      end
+
+      def self.parse_backtrace(trace)
+        trace.map do |line|
+          line =~ /(.*)\:(\d+)\:in `(.*)'/
+          { :method => $3, :line_no => $2.to_i, :file => $1 }
+        end
+      end
+
+      class Node
+        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!
+          Node.prune!(@children)
+        end
+
+        def self.prune!(kids)
+          kids.delete_if { |child| child.to_prune }
+          kids.each { |child| child.prune! }
+        end
+      end
+
+    end
+  end
+end