newrelic_rpm 3.6.7.159 → 3.6.8.164

data/lib/new_relic/agent/configuration/mask_defaults.rb

@@ -6,8 +6,8 @@ module NewRelic
   module Agent
     module Configuration
       MASK_DEFAULTS = {
-        :'thread_profiler' =>         Proc.new { !NewRelic::Agent::Commands::ThreadProfiler.is_supported? },
-        :'thread_profiler.enabled' => Proc.new { !NewRelic::Agent::Commands::ThreadProfiler.is_supported? }
+        :'thread_profiler' =>         Proc.new { !NewRelic::Agent::Threading::BacktraceService.is_supported? },
+        :'thread_profiler.enabled' => Proc.new { !NewRelic::Agent::Threading::BacktraceService.is_supported? }
       }
     end
   end

data/lib/new_relic/agent/configuration/server_source.rb

@@ -33,7 +33,7 @@ module NewRelic
             :'transaction_tracer.enabled' => 'collect_traces',
             :'slow_sql.enabled'           => 'collect_traces',
             :'error_collector.enabled'    => 'collect_errors',
-            :'request_sampler.enabled'    => 'collect_analytics_events'
+            :'analytics_events.enabled'   => 'collect_analytics_events'
           }
           gated_features.each do |feature, gate_key|
             if server_config.has_key?(gate_key)

data/lib/new_relic/agent/instrumentation/action_controller_subscriber.rb

@@ -99,6 +99,8 @@ module NewRelic
                                   :request => event.payload[:request],
                                   :filtered_params => filter(event.payload[:params]))
           txn.apdex_start = (event.queue_start || event.time)
+          txn.name = event.metric_name
+
           event.scope = Agent.instance.stats_engine \
             .push_scope(:action_controller, event.time)
         end

data/lib/new_relic/agent/instrumentation/controller_instrumentation.rb

@@ -320,17 +320,11 @@ module NewRelic
 
             begin
               NewRelic::Agent::BusyCalculator.dispatcher_start txn.start_time
-              result = if block_given?
-                         yield
-                       else
-                         perform_action_without_newrelic_trace(*args)
-                       end
-              if defined?(request) && request && defined?(response) && response
-                if !Agent.config[:disable_mobile_headers]
-                  NewRelic::Agent::BrowserMonitoring.insert_mobile_response_header(request, response)
-                end
+              if block_given?
+                yield
+              else
+                perform_action_without_newrelic_trace(*args)
               end
-              result
             rescue => e
               txn.notice_error(e)
               raise

data/lib/new_relic/agent/instrumentation/rails3/action_controller.rb

@@ -132,7 +132,7 @@ end
 DependencyDetection.defer do
   @name = :rails31_view
 
-  # We can't be sure that this wil work with future versions of Rails 3.
+  # We can't be sure that this will work with future versions of Rails 3.
   # Currently enabled for Rails 3.1 and 3.2
   depends_on do
     defined?(::Rails) && ::Rails::VERSION::MAJOR.to_i == 3 && ([1,2].member?(::Rails::VERSION::MINOR.to_i))
@@ -155,8 +155,8 @@ DependencyDetection.defer do
         # This is needed for rails 3.2 compatibility
         @details = extract_details(options) if respond_to? :extract_details, true
         identifier = determine_template(options) ? determine_template(options).identifier : nil
-        str = "View/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.template_metric(identifier, options)}/Rendering"
-        trace_execution_scoped str do
+        scope_name = "View/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.template_metric(identifier, options)}/Rendering"
+        trace_execution_scoped scope_name do
           render_without_newrelic(context, options)
         end
       end
@@ -168,17 +168,16 @@ DependencyDetection.defer do
     ActionView::PartialRenderer.class_eval do
       include NewRelic::Agent::MethodTracer
 
-      def render_with_newrelic(*args, &block)
-        setup(*args, &block)
-        identifier = find_partial ? find_partial.identifier : nil
-        str = "View/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.template_metric(identifier)}/Partial"
-        trace_execution_scoped str do
-          render_without_newrelic(*args, &block)
+      def instrument_with_newrelic(name, payload = {}, &block)
+        identifier = payload[:identifier]
+        scope_name = "View/#{NewRelic::Agent::Instrumentation::Rails3::ActionView::NewRelic.template_metric(identifier)}/Partial"
+        trace_execution_scoped(scope_name) do
+          instrument_without_newrelic(name, payload, &block)
         end
       end
 
-      alias_method :render_without_newrelic, :render
-      alias_method :render, :render_with_newrelic
+      alias_method :instrument_without_newrelic, :instrument
+      alias_method :instrument, :instrument_with_newrelic
     end
   end
 end

data/lib/new_relic/agent/memory_logger.rb

@@ -0,0 +1,52 @@
+# 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.
+
+# Base class for startup logging and testing in multiverse
+
+module NewRelic
+  module Agent
+    class MemoryLogger
+      def initialize
+        @messages = []
+      end
+
+      def is_startup_logger?
+        true
+      end
+
+      attr_accessor :messages, :level
+
+      def fatal(*msgs)
+        messages << [:fatal, msgs]
+      end
+
+      def error(*msgs)
+        messages << [:error, msgs]
+      end
+
+      def warn(*msgs)
+        messages << [:warn, msgs]
+      end
+
+      def info(*msgs)
+        messages << [:info, msgs]
+      end
+
+      def debug(*msgs)
+        messages << [:debug, msgs]
+      end
+
+      def log_exception(level, e, backtrace_level=level)
+        messages << [:log_exception, [level, e, backtrace_level]]
+      end
+
+      def dump(logger)
+        messages.each do |(method, args)|
+          logger.send(method, *args)
+        end
+        messages.clear
+      end
+    end
+  end
+end

data/lib/new_relic/agent/new_relic_service.rb

@@ -141,6 +141,10 @@ module NewRelic
         invoke_remote(:agent_command_results, @agent_id, results)
       end
 
+      def get_xray_metadata(xray_ids)
+        invoke_remote(:get_xray_metadata, @agent_id, *xray_ids)
+      end
+
       # Send fine-grained analytic data to the collector.
       def analytic_event_data(data)
         data.collect! {|hash| [hash] }

data/lib/new_relic/agent/request_sampler.rb

@@ -13,9 +13,9 @@ class NewRelic::Agent::RequestSampler
           MonitorMixin
 
   # The namespace and keys of config values
-  CONFIG_NAMESPACE = 'request_sampler'
-  MAX_SAMPLES_KEY  = "#{CONFIG_NAMESPACE}.max_samples".to_sym
-  ENABLED_KEY      = "#{CONFIG_NAMESPACE}.enabled".to_sym
+  MAX_SAMPLES_KEY  = :'analytics_events.max_samples_stored'
+  ENABLED_KEY      = :'analytics_events.enabled'
+  ENABLED_TXN_KEY  = :'analytics_events.transactions.enabled'
 
   # The type field of the sample
   SAMPLE_TYPE              = 'Transaction'
@@ -42,26 +42,39 @@ class NewRelic::Agent::RequestSampler
   public
   ######
 
-  ### Fetch a copy of the sampler's gathered samples. (Synchronized)
+  # Fetch a copy of the sampler's gathered samples. (Synchronized)
   def samples
     return self.synchronize { @samples.to_a }
   end
 
-
-  # Clear any existing samples and reset the last sample time. (Synchronized)
-  def reset
+  # Clear any existing samples, reset the last sample time, and return the
+  # previous set of samples. (Synchronized)
+  def harvest
     NewRelic::Agent.logger.debug "Resetting RequestSampler"
 
     sample_count, request_count = 0
+    old_samples = nil
 
     self.synchronize do
       sample_count = @samples.size
       request_count = @samples.seen
+      old_samples = @samples.to_a
       @samples.reset
       @notified_full = false
     end
 
     record_sampling_rate(request_count, sample_count) if @enabled
+    old_samples
+  end
+
+  alias_method :reset, :harvest
+
+  # Merge samples back into the buffer, for example after a failed
+  # transmission to the collector. (Synchronized)
+  def merge(old_samples)
+    self.synchronize do
+      old_samples.each { |s| @samples.append(s) }
+    end
   end
 
   def record_sampling_rate(request_count, sample_count)
@@ -90,7 +103,12 @@ class NewRelic::Agent::RequestSampler
 
     NewRelic::Agent.config.register_callback(ENABLED_KEY) do |enabled|
       NewRelic::Agent.logger.info "%sabling the Request Sampler." % [ enabled ? 'En' : 'Dis' ]
-      @enabled = enabled
+      @enabled = enabled && NewRelic::Agent.config[ENABLED_TXN_KEY]
+    end
+
+    NewRelic::Agent.config.register_callback(ENABLED_TXN_KEY) do |enabled|
+      NewRelic::Agent.logger.info "%sabling the Request Sampler." % [ enabled ? 'En' : 'Dis' ]
+      @enabled = enabled && NewRelic::Agent.config[ENABLED_KEY]
     end
   end
 
@@ -100,14 +118,15 @@ class NewRelic::Agent::RequestSampler
   end
 
   # Event handler for the :transaction_finished event.
-  def on_transaction_finished( metric, start_timestamp, duration, options={} )
+  def on_transaction_finished(payload)
     return unless @enabled
+    return unless NewRelic::Agent::Transaction.transaction_type_is_web?(payload[:type])
     sample = {
-      TIMESTAMP_KEY => float(start_timestamp),
-      NAME_KEY      => string(metric),
-      DURATION_KEY  => float(duration),
+      TIMESTAMP_KEY => float(payload[:start_timestamp]),
+      NAME_KEY      => string(payload[:name]),
+      DURATION_KEY  => float(payload[:duration]),
       TYPE_KEY      => SAMPLE_TYPE
-    }.merge(options)
+    }.merge((payload[:overview_metrics] || {}))
 
     is_full = self.synchronize { @samples.append(sample) }
     notify_full if is_full && !@notified_full

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

@@ -36,9 +36,12 @@ module NewRelic
         end
 
         def self.supported_on_this_platform?
-          # Process.times on JRuby reports wall clock elapsed time,
-          # not actual cpu time used, so we cannot use this sampler there.
-          not defined?(JRuby)
+          # Process.times on JRuby < 1.7.0 reports wall clock elapsed time,
+          # not actual cpu time used, so this sampler can only be used on JRuby >= 1.7.0.
+          if defined?(JRuby)
+            return JRUBY_VERSION >= '1.7.0'
+          end
+          true
         end
 
         def poll

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

@@ -32,7 +32,8 @@ module NewRelic
             ::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/ }
+          bt.reject! { |t| t.include?('/newrelic_rpm-') } unless profile_agent_code
+          bt
         end
       end
 

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

@@ -7,62 +7,115 @@ module NewRelic
     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
+        attr_reader :file, :method, :line_no, :children, :raw_line
+        attr_accessor :runnable_count, :depth
+
+        def initialize(line)
+          if line
+            @raw_line = line
+            @root = false
+          else
+            @root = true
+          end
+
           @children = []
           @runnable_count = 0
-          @to_prune = false
           @depth = 0
+        end
+
+        def root?
+          @root
+        end
+
+        def empty?
+          root? && @children.empty?
+        end
 
-          parent.add_child(self) if parent
+        def find(raw_line)
+          @children.find { |child| child.raw_line == raw_line }
         end
 
         def ==(other)
-          @file == other.file &&
-            @method == other.method &&
-            @line_no == other.line_no
+          (
+            (root? && other.root? || @raw_line == other.raw_line) &&
+            (
+              @depth == other.depth &&
+              @runnable_count == other.runnable_count
+            )
+          )
         end
 
         def total_count
           @runnable_count
         end
 
+        def aggregate(backtrace)
+          current = self
+
+          backtrace.reverse_each do |frame|
+            existing_node = current.find(frame)
+            if existing_node
+              node = existing_node
+            else
+              node = Threading::BacktraceNode.new(frame)
+              current.add_child_unless_present(node)
+            end
+
+            node.runnable_count += 1
+            current = node
+          end
+        end
+
         # Descending order on count, ascending on depth of nodes
-        def order_for_pruning(y)
-          [-runnable_count, depth] <=> [-y.runnable_count, y.depth]
+        def <=>(other)
+          [-runnable_count, depth] <=> [-other.runnable_count, other.depth]
+        end
+
+        def flatten
+          initial = self.root? ? [] : [self]
+          @children.inject(initial) { |all, child| all.concat(child.flatten) }
         end
 
         include NewRelic::Coerce
 
         def to_array
-          [[
-            string(@file),
-            string(@method),
-            int(@line_no)
-          ],
+          child_arrays = @children.map { |c| c.to_array }
+          return child_arrays if root?
+          file, method, line = parse_backtrace_frame(@raw_line)
+          [
+            [
+              string(file),
+              string(method),
+              int(line)
+            ],
             int(@runnable_count),
             0,
-            @children.map {|c| c.to_array}]
+            child_arrays
+          ]
         end
 
-        def add_child(child)
+        def add_child_unless_present(child)
           child.depth = @depth + 1
           @children << child unless @children.include? child
         end
 
-        def prune!
-          BacktraceNode.prune!(@children)
+        def prune!(targets)
+          @children.delete_if { |child| targets.include?(child) }
+          @children.each { |child| child.prune!(targets) }
+        end
+
+        def dump_string(indent=0)
+          file, method, line = parse_backtrace_frame(@raw_line)
+          result = "#{" " * indent}#<BacktraceNode:#{object_id} [#{@runnable_count}] #{@file}:#{@line_no} in #{@method}>"
+          child_results = @children.map { |c| c.dump_string(indent+2) }.join("\n")
+          result << "\n" unless child_results.empty?
+          result << child_results
         end
 
-        def self.prune!(kids)
-          kids.delete_if { |child| child.to_prune }
-          kids.each { |child| child.prune! }
+        # Returns [filename, method, line number]
+        def parse_backtrace_frame(frame)
+          frame =~ /(.*)\:(\d+)\:in `(.*)'/
+          [$1, $3, $2] # sic
         end
       end
 

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

@@ -0,0 +1,264 @@
+# 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 BacktraceService
+        ALL_TRANSACTIONS = "**ALL**".freeze
+
+        def self.is_supported?
+          RUBY_VERSION >= "1.9.2"
+        end
+
+        attr_reader :worker_loop, :buffer, :effective_polling_period,
+                    :overhead_percent_threshold
+        attr_accessor :worker_thread, :profile_agent_code
+
+        def initialize(event_listener=nil)
+          @profiles = {}
+          @buffer = {}
+
+          # synchronizes access to @profiles and @buffer above
+          @lock = Mutex.new
+
+          @running = false
+          @profile_agent_code = false
+          @worker_loop = NewRelic::Agent::WorkerLoop.new
+
+          # Memoize overhead % to avoid getting stale OR looked up every poll
+          @overhead_percent_threshold = NewRelic::Agent.config[:'xray_session.max_profile_overhead']
+          NewRelic::Agent.config.register_callback(:'xray_session.max_profile_overhead') do |new_value|
+            @overhead_percent_threshold = new_value
+          end
+
+          if event_listener
+            event_listener.subscribe(:transaction_finished, &method(:on_transaction_finished))
+          end
+        end
+
+        # Public interface
+
+        def running?
+          @running
+        end
+
+        def subscribe(transaction_name, command_arguments={})
+          if !self.class.is_supported?
+            NewRelic::Agent.logger.debug("Backtracing not supported, so not subscribing transaction '#{transaction_name}'")
+            return
+          end
+
+          NewRelic::Agent.logger.debug("Backtrace Service subscribing transaction '#{transaction_name}'")
+
+          profile = ThreadProfile.new(command_arguments)
+
+          @lock.synchronize do
+            @profiles[transaction_name] = profile
+            update_values_from_profiles
+          end
+
+          start
+          profile
+        end
+
+        def unsubscribe(transaction_name)
+          return unless self.class.is_supported?
+
+          NewRelic::Agent.logger.debug("Backtrace Service unsubscribing transaction '#{transaction_name}'")
+          @lock.synchronize do
+            @profiles.delete(transaction_name)
+            if @profiles.empty?
+              stop
+            else
+              update_values_from_profiles
+            end
+          end
+        end
+
+        def update_values_from_profiles
+          self.effective_polling_period = find_effective_polling_period
+          self.profile_agent_code = should_profile_agent_code?
+        end
+
+        def subscribed?(transaction_name)
+          @lock.synchronize do
+            @profiles.has_key?(transaction_name)
+          end
+        end
+
+        def harvest(transaction_name)
+          @lock.synchronize do
+            if @profiles[transaction_name]
+              profile = @profiles.delete(transaction_name)
+              profile.finished_at = Time.now
+              @profiles[transaction_name] = ThreadProfile.new(profile.command_arguments)
+              profile
+            end
+          end
+        end
+
+        def on_transaction_finished(payload)
+          name     = payload[:name]
+          start    = payload[:start_timestamp]
+          duration = payload[:duration]
+          thread   = payload[:thread] || Thread.current
+          @lock.synchronize do
+            backtraces = @buffer.delete(thread)
+            if backtraces && @profiles.has_key?(name)
+              aggregate_backtraces(backtraces, name, start, duration, thread)
+            end
+          end
+        end
+
+        # Internals
+
+        # This method is expected to be called with @lock held.
+        def aggregate_backtraces(backtraces, name, start, duration, thread)
+          end_time = start + duration
+          backtraces.each do |(timestamp, backtrace)|
+            if timestamp >= start && timestamp < end_time
+              @profiles[name].aggregate(backtrace, :request, thread)
+            end
+          end
+        end
+
+        def start
+          return if @running || !self.class.is_supported?
+
+          @running = true
+          self.worker_thread = AgentThread.new('Backtrace Service') do
+            begin
+              # Not passing period because we expect it's already been set.
+              self.worker_loop.run(&method(:poll))
+            ensure
+              NewRelic::Agent.logger.debug("Exiting New Relic thread: Backtrace Service")
+            end
+          end
+        end
+
+        # This method is expected to be called with @lock held
+        def stop
+          return unless @running
+          @running = false
+          self.worker_loop.stop
+
+          @buffer = {}
+        end
+
+        def effective_polling_period=(new_period)
+          @effective_polling_period = new_period
+          self.worker_loop.period = new_period
+        end
+
+        def poll
+          poll_start = Time.now
+
+          @lock.synchronize do
+            AgentThread.list.each do |thread|
+              sample_thread(thread)
+            end
+            @profiles.values.each { |c| c.increment_poll_count }
+            @buffer.delete_if { |thread, _| !thread.alive? }
+          end
+
+          end_time = Time.now
+          adjust_polling_time(end_time, poll_start)
+          record_supportability_metrics(end_time, poll_start)
+        end
+
+        # This method is expected to be called with @lock held.
+        attr_reader :profiles
+
+        # This method is expected to be called with @lock held.
+        def should_buffer?(bucket)
+          bucket == :request && @profiles.keys.any? { |k| k != ALL_TRANSACTIONS }
+        end
+
+        # This method is expected to be called with @lock held.
+        def need_backtrace?(bucket)
+          (
+            bucket != :ignore &&
+            (@profiles[ALL_TRANSACTIONS] || should_buffer?(bucket))
+          )
+        end
+
+        MAX_BUFFER_LENGTH = 500
+
+        # This method is expected to be called with @lock held.
+        def buffer_backtrace_for_thread(thread, timestamp, backtrace, bucket)
+          if should_buffer?(bucket)
+            @buffer[thread] ||= []
+            if @buffer[thread].length < MAX_BUFFER_LENGTH
+              @buffer[thread] << [timestamp, backtrace]
+            else
+              NewRelic::Agent.increment_metric('Supportability/XraySessions/DroppedBacktraces')
+            end
+          end
+        end
+
+        # This method is expected to be called with @lock held.
+        def aggregate_global_backtrace(backtrace, bucket, thread)
+          if @profiles[ALL_TRANSACTIONS]
+            @profiles[ALL_TRANSACTIONS].aggregate(backtrace, bucket, thread)
+          end
+        end
+
+        # This method is expected to be called with @lock held.
+        def sample_thread(thread)
+          bucket = AgentThread.bucket_thread(thread, @profile_agent_code)
+
+          if need_backtrace?(bucket)
+            timestamp = Time.now.to_f
+            backtrace = AgentThread.scrub_backtrace(thread, @profile_agent_code)
+            aggregate_global_backtrace(backtrace, bucket, thread)
+            buffer_backtrace_for_thread(thread, timestamp, backtrace, bucket)
+          end
+        end
+
+        # This method is expected to be called with @lock held.
+        def find_effective_polling_period
+          @profiles.values.map { |p| p.requested_period }.min
+        end
+
+        # This method is expected to be called with @lock held.
+        def should_profile_agent_code?
+          @profiles.values.any? { |p| p.profile_agent_code }
+        end
+
+        # If our overhead % exceeds the threshold, bump the next poll period
+        # relative to how much larger our overhead is than allowed
+        def adjust_polling_time(now, poll_start)
+          duration = now - poll_start
+          overhead_percent = duration / effective_polling_period
+
+          if overhead_percent > self.overhead_percent_threshold
+            scale_up_by = overhead_percent / self.overhead_percent_threshold
+            worker_loop.period = effective_polling_period * scale_up_by
+          else
+            worker_loop.period = effective_polling_period
+          end
+        end
+
+        def record_supportability_metrics(now, poll_start)
+          record_polling_time(now, poll_start)
+          record_skew(poll_start)
+        end
+
+        def record_polling_time(now, poll_start)
+          NewRelic::Agent.record_metric('Supportability/ThreadProfiler/PollingTime', now - poll_start)
+        end
+
+        def record_skew(poll_start)
+          if @last_poll
+            skew = poll_start - @last_poll - worker_loop.period
+            NewRelic::Agent.record_metric('Supportability/ThreadProfiler/Skew', skew)
+          end
+          @last_poll = poll_start
+        end
+
+      end
+    end
+  end
+end