newrelic_rpm 3.6.8.168 → 3.6.9.171

data/.gitignore

@@ -22,3 +22,4 @@ lib/new_relic/build.rb
 .pryrc
 .tm_properties
 .bundle
+.yardoc

data/.yardopts

@@ -0,0 +1,17 @@
+--non-transitive-tag api
+--api public
+lib/new_relic/agent.rb
+lib/new_relic/agent/method_tracer.rb
+lib/new_relic/agent/instrumentation/controller_instrumentation.rb
+lib/new_relic/agent/instrumentation/rack.rb
+lib/new_relic/agent/instrumentation/metric_frame.rb
+lib/new_relic/agent/transaction.rb
+lib/new_relic/rack/developer_mode.rb
+lib/new_relic/rack/agent_hooks.rb
+lib/new_relic/rack/browser_monitoring.rb
+lib/new_relic/rack/error_collector.rb
+lib/new_relic/rack.rb
+-
+LICENSE
+CHANGELOG
+GUIDELINES_FOR_CONTRIBUTING.md

data/CHANGELOG

@@ -1,5 +1,48 @@
 # New Relic Ruby Agent Release Notes #
 
+## v3.6.9 ##
+
+  * Experimental Rubinius 2.x support
+
+  The agent is now being tested against the latest version of Rubinius. While
+  support is still considered experimental, you can track the progress at
+  http://docs.newrelic.com/docs/ruby/rubinius for up to date status.
+
+  * Capture arguments for Resque and Sidekiq jobs
+
+  The agent can optionally record arguments for your Resque and Sidekiq jobs on
+  transaction traces and traced errors. This is disabled by default, but may be
+  enabled by setting resque.capture_params or sidekiq.capture_params.
+
+  Thanks to Juan Ignacio Pumarino, Ken Mayer, Paul Henry, and Eric Saxby for
+  their help with this feature!
+
+  * Supported versions rake task and documentation
+
+  We've improved our documentation for what Ruby and gem versions we support.
+  Run `rake newrelic:supported_versions` or see the latest agent's versions at
+  https://docs.newrelic.com/docs/ruby/supported-frameworks.
+
+  * ActiveRecord 4.0 explain plans for JRuby and Rubinius
+
+  The agent's ActiveRecord 4.0 instrumentation could not gather SQL explain
+  plans on JRuby by default because of a dependency on ObjectSpace, which isn't
+  avialable by default. This has been fixed.
+
+  * Fix for Curb http_put_with_newrelic
+
+  A bug in the agent caused PUT calls in the Curb gem to crash. This has been
+  fixed. Thanks to Michael D'Auria and Kirk Diggler for the contributions!
+
+  * Fix for head position on RUM injection
+
+  Certain unusual HTML documents resulted in browser monitoring injecting
+  incorrect content. Thanks Alex McHale for the contribution!
+
+  * Specify the Content-Type header in developer mode
+
+  Thanks Jared Ning for the contribution!
+
 ## v3.6.8 ##
 
   * X-Ray Sessions support
@@ -8,6 +51,11 @@
   profiling for web transactions. For full details see our X-Ray sessions
   documentation at https://newrelic.com/docs/site/xray-sessions.
 
+  * Percentiles and Histograms
+
+  The Ruby Agent now captures data that provides percentile and histogram views
+  in the New Relic UI.
+
   * CPU metrics re-enabled for JRuby >= 1.7.0
 
   To work around a JRuby bug, the Ruby agent stopped gathering CPU metrics on

data/README.md

@@ -9,27 +9,29 @@ dual-purposed as a either a Rails plugin or a Gem, hosted on
 
 The New Relic Ruby Agent runs in one of two modes:
 
-#### Production Mode
-
+**Production Mode**
 Low overhead instrumentation that captures detailed information on
 your application running in production and transmits them to
 newrelic.com where you can monitor them in real time.
 
-#### Developer Mode
-
+**Developer Mode**
 A Rack middleware that maps `/newrelic` to an application for showing
 detailed performance metrics on a page by page basis.  Installed
 automatically in Rails applications.
 
 ## Supported Environments
 
-* Ruby 1.8.6, 1.8.7, REE, 1.9.x, 2.0.x
+* Ruby 1.8.7, REE, 1.9.x, 2.0.x
 * JRuby 1.6 and 1.7
-* Rails 2.0 or later for Production Mode
+* Rubinius 2.x (Experimental support only)
+* Rails 2.1 or later for Production Mode
 * Rails 2.3 or later for Developer Mode
 * Sinatra
 * Rack
 
+An up to date list of Ruby versions and frameworks for the latest agent
+can be found on [our docs site](http://docs.newrelic.com/docs/ruby/supported-frameworks).
+
 Any Rack based framework should work but may not be tested.  Install
 the Ruby Agent as a gem and add the Developer Mode middleware if
 desired.  Report any problems to support@newrelic.com.

data/lib/new_relic/agent.rb

@@ -35,6 +35,8 @@ require 'new_relic/control'
 # For detailed information on customizing the Ruby Agent
 # please visit our {support and documentation site}[http://support.newrelic.com].
 #
+# @api public
+#
 module NewRelic
   # == Ruby Agent APIs
   # This module contains the public API methods for the Ruby Agent.
@@ -61,6 +63,9 @@ module NewRelic
   # Refer to the online docs at support.newrelic.com to see how to
   # access the data collected by custom instrumentation, or e-mail
   # support at New Relic for help.
+  #
+  # @api public
+  #
   module Agent
     extend self
     extend Forwardable
@@ -220,7 +225,12 @@ module NewRelic
     # Return a NewRelic::Agent::Stats that accepts data
     # via calls to add_data_point(value).
     #
+    # This method is deprecated in favor of record_metric and increment_metric,
+    # and is not thread-safe.
+    #
+    # @api public
     # @deprecated
+    #
     def get_stats(metric_name, use_scope=false)
       agent.stats_engine.get_stats(metric_name, use_scope)
     end
@@ -242,6 +252,8 @@ module NewRelic
     # file logger.  The setting for the newrelic.yml section to use
     # (ie, RAILS_ENV) can be overridden with an :env argument.
     #
+    # @api public
+    #
     def manual_start(options={})
       raise "Options must be a hash" unless Hash === options
       if options[:start_channel_listener]
@@ -272,6 +284,9 @@ module NewRelic
     # * <tt>:keep_retrying => false</tt> if we try to initiate a new
     #   connection, this tells me to only try it once so this method returns
     #   quickly if there is some kind of latency with the server.
+    #
+    # @api public
+    #
     def after_fork(options={})
       agent.after_fork(options)
     end
@@ -283,6 +298,9 @@ module NewRelic
 
     # Shutdown the agent.  Call this before exiting.  Sends any queued data
     # and kills the background thread.
+    #
+    # @api public
+    #
     def shutdown(options={})
       agent.shutdown(options)
     end
@@ -293,6 +311,9 @@ module NewRelic
     # when the agent is not running it's better to use this method to
     # register instrumentation than just loading the files directly,
     # although that probably also works.
+    #
+    # @api public
+    #
     def add_instrumentation(file_pattern)
       NewRelic::Control.instance.add_instrumentation file_pattern
     end
@@ -311,6 +332,8 @@ module NewRelic
     #       my_obfuscator(sql)
     #    end
     #
+    # @api public
+    #
     def set_sql_obfuscator(type = :replace, &block)
       NewRelic::Agent::Database.set_sql_obfuscator(type, &block)
     end
@@ -325,6 +348,8 @@ module NewRelic
     #     ...
     #   end
     #
+    # @api public
+    #
     def disable_sql_recording
       state = agent.set_record_sql(false)
       begin
@@ -334,25 +359,11 @@ module NewRelic
       end
     end
 
-
-    # Subscribe to events of +event_type+, calling the given +handler+
-    # when one is sent.
-    def subscribe(event_type, &handler)
-      agent.events.subscribe( event_type, &handler )
-    end
-
-
-    # Fire an event of the specified +event_type+, passing it an the given +args+
-    # to any registered handlers.
-    def notify(event_type, *args)
-      agent.events.notify( event_type, *args )
-    rescue => err
-      NewRelic::Agent.logger.debug "Ignoring exception during %p event notification" % [event_type]
-    end
-
-
     # This method disables the recording of transaction traces in the given
     # block.  See also #disable_all_tracing
+    #
+    # @api public
+    #
     def disable_transaction_tracing
       state = agent.set_record_tt(false)
       begin
@@ -365,6 +376,9 @@ module NewRelic
     # Cancel the collection of the current transaction in progress, if
     # any.  Only affects the transaction started on this thread once
     # it has started and before it has completed.
+    #
+    # @api public
+    #
     def abort_transaction!
       Transaction.abort_transaction!
     end
@@ -374,6 +388,9 @@ module NewRelic
     # track of the first entry point and turn on tracing again after
     # leaving that block.  This uses the thread local
     # +newrelic_untrace+
+    #
+    # @api public
+    #
     def disable_all_tracing
       agent.push_trace_execution_flag(false)
       yield
@@ -407,6 +424,8 @@ module NewRelic
     #
     # Return the new block or the existing filter Proc if no block is passed.
     #
+    # @api public
+    #
     def ignore_error_filter(&block)
       agent.error_collector.ignore_error_filter(&block)
     end
@@ -425,6 +444,8 @@ module NewRelic
     #
     # Anything left over is treated as custom params.
     #
+    # @api public
+    #
     def notice_error(exception, options={})
       Transaction.notice_error(exception, options)
       nil # don't return a noticed error datastructure. it can only hurt.
@@ -433,6 +454,8 @@ module NewRelic
     # Add parameters to the current transaction trace (and traced error if any)
     # on the call stack.
     #
+    # @api public
+    #
     def add_custom_parameters(params)
       Transaction.add_custom_parameters(params)
     end
@@ -446,6 +469,8 @@ module NewRelic
     # * <tt>:account</tt> => account name or ID
     # * <tt>:product</tt> => product name or level
     #
+    # @api public
+    #
     def set_user_attributes(attributes)
       Transaction.set_user_attributes(attributes)
     end
@@ -472,6 +497,7 @@ module NewRelic
     # The default category is the same as the running transaction.
     #
     # @api public
+    #
     def set_transaction_name(name, options={})
       if Transaction.current
         namer = Instrumentation::ControllerInstrumentation::TransactionNamer.new(self)
@@ -484,6 +510,7 @@ module NewRelic
     # want to modify the default name.
     #
     # @api public
+    #
     def get_transaction_name
       if Transaction.current
         namer = Instrumentation::ControllerInstrumentation::TransactionNamer.new(self)
@@ -503,6 +530,9 @@ module NewRelic
     # * <tt>model</tt> is the DB model class
     # * <tt>method</tt> is the name of the finder method or other
     #   method to identify the operation with.
+    #
+    # @api public
+    #
     def with_database_metric_name(model, method, &block)
       if txn = Transaction.current
         txn.with_database_metric_name(model, method, &block)
@@ -537,10 +567,28 @@ module NewRelic
     #   request parameters.
     # * <tt>'custom_params' => hash</tt> to record extra information in traced errors
     #
+    # @api public
+    # @deprecated
+    #
     def record_transaction(response_sec, options = {})
       agent.record_transaction(response_sec, options)
     end
 
+    # Subscribe to events of +event_type+, calling the given +handler+
+    # when one is sent.
+    def subscribe(event_type, &handler)
+      agent.events.subscribe( event_type, &handler )
+    end
+
+
+    # Fire an event of the specified +event_type+, passing it an the given +args+
+    # to any registered handlers.
+    def notify(event_type, *args)
+      agent.events.notify( event_type, *args )
+    rescue => err
+      NewRelic::Agent.logger.debug "Ignoring exception during %p event notification" % [event_type]
+    end
+
     # Returns a Javascript string which should be injected into the very top of the response body
     #
     def browser_timing_header

data/lib/new_relic/agent/agent.rb

@@ -48,7 +48,6 @@ module NewRelic
         @cross_app_monitor     = NewRelic::Agent::CrossAppMonitor.new(@events)
         @error_collector       = NewRelic::Agent::ErrorCollector.new
         @transaction_rules     = NewRelic::Agent::RulesEngine.new
-        @metric_rules          = NewRelic::Agent::RulesEngine.new
         @request_sampler       = NewRelic::Agent::RequestSampler.new(@events)
         @harvest_samplers      = NewRelic::Agent::SamplerCollection.new(@events)
 
@@ -56,7 +55,6 @@ module NewRelic
         @connect_attempts   = 0
         @environment_report = nil
 
-        @last_harvest_time = Time.now
         @harvest_lock = Mutex.new
         @obfuscator = lambda {|sql| NewRelic::Agent::Database.default_sql_obfuscator(sql) }
       end
@@ -106,28 +104,8 @@ module NewRelic
         # collector on connect.  The former are applied during txns,
         # the latter during harvest.
         attr_reader :transaction_rules
-        attr_reader :metric_rules
         attr_reader :harvest_lock
 
-        # Returns the length of the unsent errors array, if it exists,
-        # otherwise nil
-        def unsent_errors_size
-          @unsent_errors.length if @unsent_errors
-        end
-
-        # Returns the length of the traces array, if it exists,
-        # otherwise nil
-        def unsent_traces_size
-          @traces.length if @traces
-        end
-
-        # Initializes the unsent timeslice data hash, if needed, and
-        # returns the number of keys it contains
-        def unsent_timeslice_data
-          @unsent_timeslice_data ||= {}
-          @unsent_timeslice_data.keys.length
-        end
-
         # fakes out a transaction that did not happen in this process
         # by creating apdex, summary metrics, and recording statistics
         # for the transaction
@@ -209,7 +187,7 @@ module NewRelic
           # Clear out stats that are left over from parent process
           reset_stats
 
-          generate_environment_report
+          generate_environment_report unless @service.is_a?(NewRelic::Agent::PipeService)
           start_worker_thread(options)
         end
 
@@ -460,6 +438,7 @@ module NewRelic
           # before Resque calls Process.daemon (Jira RUBY-857)
           def defer_for_resque?
             NewRelic::Agent.config[:dispatcher] == :resque &&
+              NewRelic::LanguageSupport.can_fork? &&
               !NewRelic::Agent::PipeChannelManager.listener.started?
           end
 
@@ -524,10 +503,10 @@ module NewRelic
         # making sure the agent is in a fresh state
         def reset_stats
           @stats_engine.reset_stats
-          @unsent_errors = []
-          @traces = nil
-          @unsent_timeslice_data = {}
-          @last_harvest_time = Time.now
+          @error_collector.reset!
+          @transaction_sampler.reset!
+          @request_sampler.reset!
+          @sql_sampler.reset!
           @launch_time = Time.now
         end
 
@@ -810,10 +789,8 @@ module NewRelic
             Agent.config.apply_config(server_config, 1)
             log_connection!(config_data) if @service
 
-            add_rules_to_engine(config_data['transaction_name_rules'],
-                                NewRelic::Agent.instance.transaction_rules)
-            add_rules_to_engine(config_data['metric_name_rules'],
-                                NewRelic::Agent.instance.metric_rules)
+            @transaction_rules = RulesEngine.from_specs(config_data['transaction_name_rules'])
+            @stats_engine.metric_rules = RulesEngine.from_specs(config_data['metric_name_rules'])
 
             # If you're adding something else here to respond to the server-side config,
             # use Agent.instance.events.subscribe(:finished_configuring) callback instead!
@@ -821,13 +798,6 @@ module NewRelic
             @beacon_configuration = BeaconConfiguration.new
           end
 
-          def add_rules_to_engine(rule_specifications, rules_engine)
-            return unless rule_specifications && rule_specifications.any?
-            rule_specifications.each do |rule_spec|
-              rules_engine << NewRelic::Agent::RulesEngine::Rule.new(rule_spec)
-            end
-          end
-
           # Logs when we connect to the server, for debugging purposes
           # - makes sure we know if an agent has not connected
           def log_connection!(config_data)
@@ -856,16 +826,10 @@ module NewRelic
           @stats_engine.merge!(metrics) if metrics
           if transaction_traces && transaction_traces.respond_to?(:any?) &&
               transaction_traces.any?
-            if @traces
-              @traces += transaction_traces
-            else
-              @traces = transaction_traces
-            end
+            @transaction_sampler.merge!(transaction_traces)
           end
           if errors && errors.respond_to?(:each)
-            errors.each do |err|
-              @error_collector.add_to_error_queue(err)
-            end
+            @error_collector.merge!(errors)
           end
         end
 
@@ -931,44 +895,21 @@ module NewRelic
 
         # calls the busy harvester and collects timeslice data to
         # send later
-        def harvest_timeslice_data(time=Time.now)
-          # this creates timeslices that are harvested below
+        def harvest_timeslice_data
           NewRelic::Agent::BusyCalculator.harvest_busy
-
-          @unsent_timeslice_data ||= {}
-          @unsent_timeslice_data = @stats_engine.harvest_timeslice_data(@unsent_timeslice_data,
-                                                                        @metric_rules)
-          @unsent_timeslice_data
+          @stats_engine.harvest
         end
 
-        # note - exceptions are logged in invoke_remote.  If an exception is encountered here,
-        # then the metric data is downsampled for another
-        # transmission later
         def harvest_and_send_timeslice_data
-          now = Time.now
-          NewRelic::Agent.record_metric('Supportability/invoke_remote', 0.0)
-          NewRelic::Agent.record_metric('Supportability/invoke_remote/metric_data', 0.0)
-          harvest_timeslice_data(now)
+          timeslices = harvest_timeslice_data
           begin
-            @service.metric_data(@last_harvest_time.to_f,
-                                  now.to_f,
-                                  @unsent_timeslice_data)
+            @service.metric_data(timeslices)
           rescue UnrecoverableServerException => e
             ::NewRelic::Agent.logger.debug e.message
+          rescue => e
+            NewRelic::Agent.logger.info("Failed to send timeslice data, trying again later. Error:", e)
+            @stats_engine.merge!(timeslices)
           end
-
-          ::NewRelic::Agent.logger.debug "#{now}: sent #{@unsent_timeslice_data.length} timeslices (#{@service.agent_id}) in #{Time.now - now} seconds"
-
-          # if we successfully invoked this web service, then clear the unsent message cache.
-          @unsent_timeslice_data = {}
-          @last_harvest_time = now
-        end
-
-        # Fills the traces array with the harvested transactions from
-        # the transaction sampler, subject to the setting for slowest
-        # transaction threshold
-        def harvest_transaction_traces
-          @traces = @transaction_sampler.harvest(@traces)
         end
 
         def harvest_and_send_slowest_sql
@@ -982,7 +923,7 @@ module NewRelic
               ::NewRelic::Agent.logger.debug e.message
             rescue => e
               ::NewRelic::Agent.logger.debug "Remerging SQL traces after #{e.class.name}: #{e.message}"
-              @sql_sampler.merge sql_traces
+              @sql_sampler.merge!(sql_traces)
             end
           end
         end
@@ -993,28 +934,27 @@ module NewRelic
         # SQL.  note that we explain only the sql statements whose
         # segments' execution times exceed our threshold (to avoid
         # unnecessary overhead of running explains on fast queries.)
-        def harvest_and_send_slowest_sample
-          harvest_transaction_traces
-
-          unless @traces.empty?
+        def harvest_and_send_transaction_traces
+          traces = @transaction_sampler.harvest
+          unless traces.empty?
             begin
-              send_slowest_sample
+              send_transaction_traces(traces)
             rescue UnrecoverableServerException => e
-              ::NewRelic::Agent.logger.debug e.message
+              # This indicates that there was a problem with the POST body, so
+              # we discard the traces rather than trying again later.
+              ::NewRelic::Agent.logger.debug("Server rejected transaction traces, discarding. Error: ", e)
+            rescue => e
+              ::NewRelic::Agent.logger.error("Failed to send transaction traces, will re-attempt next harvest. Error: ", e)
+              @transaction_sampler.merge!(traces)
             end
           end
-
-          # if we succeed sending this sample, then we don't need to keep
-          # the slowest sample around - it has been sent already and we
-          # can clear the collection and move on
-          @traces = nil
         end
 
-        def send_slowest_sample
+        def send_transaction_traces(traces)
           start_time = Time.now
-          ::NewRelic::Agent.logger.debug "Sending (#{@traces.length}) transaction traces"
+          ::NewRelic::Agent.logger.debug "Sending (#{traces.length}) transaction traces"
 
-          options = { :keep_backtraces => true }
+          options = {}
           unless NewRelic::Agent::Database.record_sql_method == :off
             options[:record_sql] = NewRelic::Agent::Database.record_sql_method
           end
@@ -1023,7 +963,7 @@ module NewRelic
             options[:explain_sql] = Agent.config[:'transaction_tracer.explain_threshold']
           end
 
-          traces = @traces.map {|trace| trace.prepare_to_send(options) }
+          traces.each { |trace| trace.prepare_to_send!(options) }
 
           @service.transaction_sample_data(traces)
           ::NewRelic::Agent.logger.debug "Sent slowest sample (#{@service.agent_id}) in #{Time.now - start_time} seconds"
@@ -1036,32 +976,21 @@ module NewRelic
           end
         end
 
-        # Gets the collection of unsent errors from the error
-        # collector. We pass back in an existing array of errors that
-        # may be left over from a previous send
-        def harvest_errors
-          @unsent_errors = @error_collector.harvest_errors(@unsent_errors)
-          @unsent_errors
-        end
-
         # Handles getting the errors from the error collector and
         # sending them to the server, and any error cases like trying
-        # to send very large errors - we drop the oldest error on the
-        # floor and try again
+        # to send very large errors
         def harvest_and_send_errors
-          harvest_errors
-          if @unsent_errors && @unsent_errors.length > 0
-            ::NewRelic::Agent.logger.debug "Sending #{@unsent_errors.length} errors"
+          errors = @error_collector.harvest_errors
+          if errors && !errors.empty?
+            ::NewRelic::Agent.logger.debug "Sending #{errors.length} errors"
             begin
-              @service.error_data(@unsent_errors)
+              @service.error_data(errors)
             rescue UnrecoverableServerException => e
               ::NewRelic::Agent.logger.debug e.message
+            rescue => e
+              ::NewRelic::Agent.logger.debug "Failed to send error traces, will try again later. Error:", e
+              @error_collector.merge!(errors)
             end
-            # if the remote invocation fails, then we never clear
-            # @unsent_errors, and therefore we can re-attempt to send on
-            # the next heartbeat.  Note the error collector maxes out at
-            # 20 instances to prevent leakage
-            @unsent_errors = []
           end
         end
 
@@ -1071,7 +1000,7 @@ module NewRelic
           begin
             @service.analytic_event_data(samples) unless samples.empty?
           rescue
-            @request_sampler.merge(samples)
+            @request_sampler.merge!(samples)
             raise
           end
         end
@@ -1095,7 +1024,7 @@ module NewRelic
           @events.notify(:before_harvest)
           @service.session do # use http keep-alive
             harvest_and_send_errors
-            harvest_and_send_slowest_sample
+            harvest_and_send_transaction_traces
             harvest_and_send_slowest_sql
             harvest_and_send_timeslice_data
             harvest_and_send_analytic_event_data