newrelic_rpm 3.6.8.168 → 3.6.9.171

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

@@ -9,10 +9,10 @@ module NewRelic
     class Transaction
       class ForcePersistSampleBuffer < TransactionSampleBuffer
 
-        MAX_SAMPLES = 10
+        CAPACITY = 10
 
-        def max_samples
-          MAX_SAMPLES
+        def capacity
+          CAPACITY
         end
 
         def allow_sample?(sample)

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

@@ -9,10 +9,10 @@ module NewRelic
     class Transaction
       class SlowestSampleBuffer < TransactionSampleBuffer
 
-        MAX_SAMPLES = 1
+        CAPACITY = 1
 
-        def max_samples
-          MAX_SAMPLES
+        def capacity
+          CAPACITY
         end
 
         def allow_sample?(sample)

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

@@ -8,6 +8,7 @@ module NewRelic
       class TransactionSampleBuffer
         attr_reader :samples
 
+        SINGLE_BUFFER_MAX = 20
         NO_SAMPLES = [].freeze
 
         def initialize
@@ -53,17 +54,35 @@ module NewRelic
         end
 
         def full?
-          @samples.length >= max_samples
+          @samples.length >= max_capacity
         end
 
-        # Our default truncation strategy is to keep max_samples worth of the
-        # longest samples. Override this method for alternate behavior.
+        # Capacity is the desired number of samples a buffer will hold. This
+        # can be user dictated via config if a feature wants.
+        #
+        # This value will be forcibly capped by the max_capacity
+        def capacity
+          raise NotImplementedError.new("TransactionSampleBuffer subclasses must provide a capacity override")
+        end
+
+        # Apply hard upper limit to the capacity to prevent users from
+        # consuming too much memory buffering TT's.
+        #
+        # A typical buffer should NOT override this method (although we do for
+        # odd things like dev-mode)
+        def max_capacity
+          capacity > SINGLE_BUFFER_MAX ? SINGLE_BUFFER_MAX : capacity
+        end
+
+        # Our default truncation strategy is to keep max_capacity
+        # 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))
+          @samples.slice!(0..-(max_capacity + 1))
         end
 
         # When pushing a scope different sample buffers potentially want to

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

@@ -20,9 +20,9 @@ module NewRelic
             @enabled = new_value
           end
 
-          @max_samples = NewRelic::Agent.config[:'xray_session.max_samples']
+          @capacity = NewRelic::Agent.config[:'xray_session.max_samples']
           NewRelic::Agent.config.register_callback(:'xray_session.max_samples') do |new_value|
-            @max_samples = new_value
+            @capacity = new_value
           end
         end
 
@@ -30,8 +30,8 @@ module NewRelic
           @xray_session_collection ||= NewRelic::Agent.instance.agent_command_router.xray_session_collection
         end
 
-        def max_samples
-          @max_samples
+        def capacity
+          @capacity
         end
 
         def truncate_samples

data/lib/new_relic/agent/transaction_sampler.rb

@@ -235,31 +235,27 @@ module NewRelic
       end
 
       # Gather transaction traces that we'd like to transmit to the server.
-      # choose_samples is responsible for determining the contents of that
-      # transmission, along with limits and ordering.
-      def harvest(previous=[])
-        return [] if !enabled?
-
-        # If no unsent transactions from last time, we explicitly pass nil!
-        previous ||= []
+      def harvest
+        return [] unless enabled?
 
         @samples_lock.synchronize do
           @last_sample = nil
-          choose_samples(previous)
+          harvest_from_sample_buffers
         end
       end
 
-      # Runs previously untransmitted samples into buffers, then chooses what
-      # to send based on each buffer's internal logic
-      def choose_samples(previous_samples)
-        append_previous_samples_to_buffers(previous_samples)
-        harvest_from_sample_buffers
+      def merge!(previous)
+        @samples_lock.synchronize do
+          @sample_buffers.each do |buffer|
+            buffer.store_previous(previous)
+          end
+        end
       end
 
-      # Previous samples are added to buffers to enforce limiting rules
-      def append_previous_samples_to_buffers(previous_samples)
-        @sample_buffers.each do |buffer|
-          buffer.store_previous(previous_samples)
+      def count
+        @samples_lock.synchronize do
+          samples = @sample_buffers.inject([]) { |all, b| all.concat(b.samples) }
+          samples.uniq.size
         end
       end
 
@@ -268,7 +264,7 @@ module NewRelic
         # want a single level flatten anyway, but, as you probably already
         # know, Ruby 1.8.6 :/
         result = []
-        @sample_buffers.each {|buffer| result.concat(buffer.harvest_samples)}
+        @sample_buffers.each { |buffer| result.concat(buffer.harvest_samples) }
         result.uniq
       end
 

data/lib/new_relic/agent/worker_loop.rb

@@ -11,6 +11,7 @@ module NewRelic
     class WorkerLoop
 
       attr_accessor :period, :propagate_errors
+      attr_reader :iterations
 
       # Optional argument :duration (in seconds) for how long the worker loop runs
       # or :limit (integer) for max number of iterations

data/lib/new_relic/control.rb

@@ -6,6 +6,7 @@ require 'yaml'
 require 'conditional_vendored_metric_parser'
 require 'conditional_vendored_dependency_detection'
 require 'new_relic/local_environment'
+require 'new_relic/language_support'
 require 'new_relic/helper'
 
 require 'singleton'

data/lib/new_relic/control/instance_methods.rb

@@ -2,7 +2,6 @@
 # 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/language_support'
 require 'new_relic/agent/null_logger'
 require 'new_relic/agent/memory_logger'
 require 'new_relic/agent/agent_logger'

data/lib/new_relic/helper.rb

@@ -52,8 +52,7 @@ module NewRelic
 
   # Load the JSON library from the standard library.
   def self::load_stdlib_json
-    # Don't even try to use 1.9.1's json.
-    return false if RUBY_VERSION == '1.9.1'
+    return false unless NewRelic::LanguageSupport.stdlib_json_usable?
 
     require 'json'
     define_method( :json_dump, &::JSON.method(:dump) )

data/lib/new_relic/language_support.rb

@@ -64,19 +64,29 @@ module NewRelic::LanguageSupport
     end
   end
 
-  def object_space_enabled?
+  def object_space_usable?
     if defined?(::JRuby) && JRuby.respond_to?(:runtime)
       JRuby.runtime.is_object_space_enabled
+    elsif defined?(::ObjectSpace) && !rubinius?
+      true
     else
-      defined?(::ObjectSpace) ? true : false
+      false
     end
   end
 
+  def rubinius?
+    defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+  end
+
   def using_version?(version)
     numbers = version.split('.')
     numbers == ::RUBY_VERSION.split('.')[0, numbers.size]
   end
 
+  def stdlib_json_usable?
+    RUBY_VERSION >= '1.9.2'
+  end
+
   def test_forkability
     child = Process.fork { exit! }
     # calling wait here doesn't seem like it should necessary, but it seems to

data/lib/new_relic/local_environment.rb

@@ -35,7 +35,7 @@ module NewRelic
     # Runs through all the objects in ObjectSpace to find the first one that
     # match the provided class
     def find_class_in_object_space(klass)
-      if NewRelic::LanguageSupport.object_space_enabled?
+      if NewRelic::LanguageSupport.object_space_usable?
         ObjectSpace.each_object(klass) do |x|
           return x
         end
@@ -117,21 +117,21 @@ module NewRelic
     end
 
     def check_for_unicorn
-      if (defined?(::Unicorn) && defined?(::Unicorn::HttpServer)) && NewRelic::LanguageSupport.object_space_enabled?
+      if (defined?(::Unicorn) && defined?(::Unicorn::HttpServer)) && NewRelic::LanguageSupport.object_space_usable?
         v = find_class_in_object_space(::Unicorn::HttpServer)
         @discovered_dispatcher = :unicorn if v
       end
     end
 
     def check_for_rainbows
-      if (defined?(::Rainbows) && defined?(::Rainbows::HttpServer)) && NewRelic::LanguageSupport.object_space_enabled?
+      if (defined?(::Rainbows) && defined?(::Rainbows::HttpServer)) && NewRelic::LanguageSupport.object_space_usable?
         v = find_class_in_object_space(::Rainbows::HttpServer)
         @discovered_dispatcher = :rainbows if v
       end
     end
 
     def check_for_delayed_job
-      if $0 =~ /delayed_job$/
+      if $0 =~ /delayed_job$/ || (File.basename($0) == 'rake' && ARGV.include?('jobs:work'))
         @discovered_dispatcher = :delayed_job
       end
     end
@@ -156,16 +156,17 @@ module NewRelic
     end
 
     def check_for_thin
-      if defined?(::Thin) && defined?(::Thin::Server) && NewRelic::LanguageSupport.object_space_enabled?
-        # This case covers the thin web dispatcher
-        # Same issue as above- we assume only one instance per process
-        ObjectSpace.each_object(Thin::Server) do |thin_dispatcher|
+      if defined?(::Thin) && defined?(::Thin::Server)
+        # If ObjectSpace is available, use it to search for a Thin::Server
+        # instance. Otherwise, just the presence of the constant is sufficient.
+        if NewRelic::LanguageSupport.object_space_usable?
+          ObjectSpace.each_object(Thin::Server) do |thin_dispatcher|
+            @discovered_dispatcher = :thin
+          end
+        else
           @discovered_dispatcher = :thin
         end
       end
-      if defined?(::Thin) && defined?(::Thin::VERSION) && !@discovered_dispatcher
-        @discovered_dispatcher = :thin
-      end
     end
 
     def check_for_litespeed

data/lib/new_relic/rack.rb

@@ -2,7 +2,16 @@
 # This file is distributed under New Relic's license terms.
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
+# @api public
 module NewRelic
+  # This module contains Rack middlewares used by the Ruby agent.
+  #
+  # Generally, these middlewares should be injected automatically when starting
+  # your application. If automatic injection into the middleware chain is not
+  # working for some reason, you may also include them manually.
+  #
+  #
+  # @api public
   module Rack
   end
 end

data/lib/new_relic/rack/agent_hooks.rb

@@ -5,6 +5,12 @@
 require 'new_relic/agent/event_listener'
 
 module NewRelic::Rack
+  # This middleware is used by the agent internally, and is usually injected
+  # automatically into the middleware chain. If automatic injection is not
+  # working, you may manually use it in your middleware chain instead.
+  #
+  # @api public
+  #
   class AgentHooks
     def initialize(app, options = {})
       @app = app

data/lib/new_relic/rack/browser_monitoring.rb

@@ -5,6 +5,13 @@
 require 'rack'
 
 module NewRelic::Rack
+  # This middleware is used by the agent for the Real user monitoring (RUM)
+  # feature, and will usually be automatically injected in the middleware chain.
+  # If automatic injection is not working, you may manually use it in your
+  # middleware chain instead.
+  #
+  # @api public
+  #
   class BrowserMonitoring
 
     def initialize(app, options = {})
@@ -76,9 +83,9 @@ module NewRelic::Rack
         # is really weird and we should punt.
         if head_pos && (head_pos < body_close)
           # rebuild the source
-          source = source[0..(head_pos-1)] <<
+          source = source[0...head_pos] <<
             header <<
-            source[head_pos..(body_close-1)] <<
+            source[head_pos...body_close] <<
             footer <<
             source[body_close..-1]
         else

data/lib/new_relic/rack/developer_mode.rb

@@ -11,6 +11,20 @@ require 'new_relic/collection_helper'
 
 module NewRelic
   module Rack
+    # This middleware provides the 'developer mode' feature of newrelic_rpm,
+    # which allows you to see data about local web transactions in development
+    # mode immediately without needing to send this data to New Relic's servers.
+    #
+    # Enabling developer mode has serious performance and security impact, and
+    # thus you should never use this middleware in a production or non-local
+    # environment.
+    #
+    # This middleware should be automatically inserted in most contexts, but if
+    # automatic middleware insertion fails, you may manually insert it into your
+    # middleware chain.
+    #
+    # @api public
+    #
     class DeveloperMode
 
       VIEW_PATH = File.expand_path('../../../../ui/views/', __FILE__)
@@ -141,7 +155,7 @@ module NewRelic
           body = render_without_layout(view, binding)
         end
         if add_rack_array
-          ::Rack::Response.new(body).finish
+          ::Rack::Response.new(body, 200, {'Content-Type' => 'text/html'}).finish
         else
           body
         end

data/lib/new_relic/rack/error_collector.rb

@@ -3,6 +3,13 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 module NewRelic::Rack
+  # This middleware is used by the agent in order to capture exceptions that
+  # occur within your web application. It will normally be injected into the
+  # middleware chain automatically, but if automatic injection fails in your
+  # environment, you may alternately include it manually.
+  #
+  # @api public
+  #
   class ErrorCollector
     def initialize(app, options={})
       @app = app

data/lib/new_relic/recipes.rb

@@ -12,6 +12,8 @@
 # The task will run on app servers except where no_release is true.
 # If it fails, it will not affect the task execution or do a rollback.
 #
+# @api public
+#
 make_notify_task = Proc.new do
 
   namespace :newrelic do

data/lib/new_relic/transaction_sample.rb

@@ -18,6 +18,7 @@ module NewRelic
     attr_accessor :params, :root_segment, :profile, :force_persist, :guid,
                   :threshold, :finished, :xray_session_id
     attr_reader :root_segment, :params, :sample_id
+    attr_writer :prepared
 
     @@start_time = Time.now
 
@@ -29,11 +30,16 @@ module NewRelic
       @params = { :segment_count => -1, :request_params => {} }
       @segment_count = -1
       @root_segment = create_segment 0.0, "ROOT"
+      @prepared = false
 
       @guid = generate_guid
       NewRelic::Agent::TransactionState.get.request_guid = @guid
     end
 
+    def prepared?
+      @prepared
+    end
+
     def count_segments
       @segment_count
     end
@@ -182,21 +188,19 @@ module NewRelic
     #
     #   :explain_sql : run EXPLAIN on all queries whose response times equal the value for this key
     #       (for example :explain_sql => 2.0 would explain everything over 2 seconds.  0.0 would explain everything.)
-    #   :keep_backtraces : keep backtraces, significantly increasing size of trace (off by default)
     #   :record_sql => [ :raw | :obfuscated] : copy over the sql, obfuscating if necessary
-    def prepare_to_send(options={})
-      sample = TransactionSample.new(@start_time, sample_id)
-
-      sample.params.merge! self.params
-      sample.guid = self.guid
-      sample.force_persist = self.force_persist if self.force_persist
-      sample.threshold = self.threshold
-      sample.xray_session_id = self.xray_session_id
-
-      build_segment_for_transfer(sample, @root_segment, sample.root_segment, options)
+    def prepare_to_send!(options={})
+      return self if @prepared
+
+      if options[:record_sql]
+        collect_explain_plans!(options[:explain_sql]) if options[:explain_sql]
+        prepare_sql_for_transmission!(options[:record_sql])
+      else
+        strip_sql!
+      end
 
-      sample.root_segment.end_trace(@root_segment.exit_timestamp)
-      sample
+      @prepared = true
+      self
     end
 
     def params=(params)
@@ -250,43 +254,30 @@ module NewRelic
       return time_delta
     end
 
-    # see prepare_to_send for what we do with options
-    #
-    # This is badly in need of refactoring
-    def build_segment_for_transfer(new_sample, source_segment, target_segment, options)
-      source_segment.called_segments.each do |source_called_segment|
-        target_called_segment = new_sample.create_segment(
-              source_called_segment.entry_timestamp,
-              source_called_segment.metric_name,
-              source_called_segment.segment_id)
-
-        target_segment.add_called_segment target_called_segment
-        source_called_segment.params.each do |k,v|
-          case k
-          when :backtrace
-            target_called_segment[k]=v if options[:keep_backtraces]
-          when :sql
-            # run an EXPLAIN on this sql if specified.
-            if options[:record_sql] && options[:record_sql] &&
-                options[:explain_sql] &&
-                source_called_segment.duration > options[:explain_sql].to_f
-              target_called_segment[:explain_plan] = source_called_segment.explain_sql
-            end
-
-            target_called_segment[:sql] = case options[:record_sql]
-              when :raw then v
-              when :obfuscated then NewRelic::Agent::Database.obfuscate_sql(v)
-              else raise "Invalid value for record_sql: #{options[:record_sql]}"
-            end.to_s if options[:record_sql]
-          when :connection_config
-            # don't copy it
-          else
-            target_called_segment[k]=v
-          end
+    def strip_sql!
+      each_segment do |segment|
+        segment.params.delete(:sql)
+      end
+    end
+
+    def collect_explain_plans!(threshold)
+      each_segment do |segment|
+        if segment[:sql] && segment.duration > threshold
+          segment[:explain_plan] = segment.explain_sql
         end
+      end
+    end
 
-        build_segment_for_transfer(new_sample, source_called_segment, target_called_segment, options)
-        target_called_segment.end_trace(source_called_segment.exit_timestamp)
+    def prepare_sql_for_transmission!(strategy)
+      each_segment do |segment|
+        if segment[:sql]
+          segment[:sql] = case strategy
+          when :raw
+            segment[:sql].to_s
+          when :obfuscated
+            NewRelic::Agent::Database.obfuscate_sql(segment[:sql]).to_s
+          end
+        end
       end
     end
   end