newrelic_rpm 3.7.0.174.beta → 3.7.0.177

data/CHANGELOG

@@ -2,12 +2,35 @@
 
 ## v3.7.0 ##
 
+  * Official Rubinius support (for Rubinius >= 2.2.1)
+
+  We're happy to say that all known issues with the Ruby agent running on 
+  Rubinius have been resolved as of Rubinius version 2.2.1! See
+  http://docs.newrelic.com/docs/ruby/rubinius for the most up-to-date status.
+
   * RUM injection updates
 
-  The Ruby agent's code for both automatically and manually injecting the Real
-  User Monitoring scripts has been updated.  This should not require
-  application changes, but does result in a different script being injected
-  than previous versions of the agent.
+  The Ruby agent's code for both automatic and manual injection of Real User
+  Monitoring scripts has been improved. No application changes are required, but
+  the new injection logic is simpler, faster, more robust, and paves the way for
+  future improvements to Real User Monitoring.
+
+  * More robust communication with New Relic
+
+  Failures when transmitting data to New Relic could cause data to be held over
+  unnecessarily to a later harvest. This has been improved both to handle
+  errors more robustly and consistently, and to send data as soon as possible.
+
+  * Fix for agent not restarting on server-side config changes
+
+  A bug in 3.6.9 caused the agent to not reset correctly after server-side
+  config changes. New settings would not be received without a full process
+  restart. This has been fixed.
+
+  * Blacklisting rake spec tasks
+
+  A blacklist helps the agent avoid starting during rake tasks. Some default
+  RSpec tasks were missing. Thanks for the contribution Kohei Hasegawa!
 
 ## v3.6.9 ##
 

data/bin/nrdebug

@@ -133,6 +133,7 @@ class RubyProcess
     backtrace_file = Tempfile.new('nrdebug_ruby_bt')
     File.chmod(0666, backtrace_file.path)
 
+    backtrace_gathering_code = 'Thread.list.each { |t| bt = t.backtrace rescue nil; puts \"#{t.inspect}\n#{bt && bt.join(\"\n\")}\n\n\" }'
     gdb_script_body = <<-END
       attach #{pid}
       t a a bt
@@ -142,6 +143,8 @@ class RubyProcess
       call (int)open("#{backtrace_file.path}", 2, 0)
       call (void)rb_backtrace()
       call (void)fflush(0)
+      call (void)rb_eval_string_protect("#{backtrace_gathering_code}",(int*)0)
+      call (void)fflush(0)
       quit
     END
     Logger.log("Using gdb script:\n#{gdb_script_body}")
@@ -212,7 +215,7 @@ class ProcessReport
           fail("Failed to attach to target process. Please try again with sudo.")
         end
         section(f, "C Backtraces")   { c_backtraces }
-        section(f, "Ruby Backtrace") { ruby_backtraces }
+        section(f, "Ruby Backtrace(s)") { ruby_backtraces }
       end
 
       section(f, "Open files") { @target.open_files }
@@ -227,13 +230,16 @@ end
 def prompt_for_confirmation(target_pid, target_cmd)
   puts "Are you sure you want to attach to PID #{target_pid} ('#{target_cmd}')}?"
   puts ''
-  puts "Extracting debug information from this process may cause it to hang, crash,"
-  puts "or otherwise malfunction. It is highly recommended that you only run this"
-  puts "script against processes that are already unresponsive."
+  puts '************************** !WARNING! **************************'
+  puts "Extracting debug information from this process may cause it to CRASH OR HANG."
+  puts ''
+  puts "It is highly recommended that you only run this script against processes that"
+  puts "are already unresponsive."
   puts ''
   puts "Additionally, the output may contain sensitive information from the program's"
   puts "command line arguments, environment, or open file list. Please examine the"
   puts "output before sharing it."
+  puts '************************** !WARNING! **************************'
   puts ''
   puts "To continue, type 'continue':"
 

data/lib/new_relic/agent.rb

@@ -85,7 +85,6 @@ module NewRelic
     require 'new_relic/agent'
     require 'new_relic/agent/stats'
     require 'new_relic/agent/chained_call'
-    require 'new_relic/agent/browser_monitoring'
     require 'new_relic/agent/cross_app_monitor'
     require 'new_relic/agent/agent'
     require 'new_relic/agent/shim_agent'
@@ -140,9 +139,6 @@ module NewRelic
     # An unrecoverable client-side error that prevents the agent from continuing
     class UnrecoverableAgentException < ServerConnectionException; end
 
-    # Reserved for future use.  Meant to represent a problem on the server side.
-    class ServerError < StandardError; end
-
     class BackgroundLoadingError < StandardError; end
 
     # placeholder name used when we cannot determine a transaction's name
@@ -291,11 +287,20 @@ module NewRelic
       agent.after_fork(options)
     end
 
-    # Clear out any unsent metric data. See NewRelic::Agent::Agent#reset_stats
-    def reset_stats
-      agent.reset_stats
+    # Clear out any data the agent has buffered but has not yet transmitted
+    # to the collector.
+    #
+    # @api public
+    def drop_buffered_data
+      agent.drop_buffered_data
     end
 
+    # Deprecated in favor of drop_buffered_data
+    #
+    # @api public
+    # @deprecated
+    def reset_stats; drop_buffered_data; end
+
     # Shutdown the agent.  Call this before exiting.  Sends any queued data
     # and kills the background thread.
     #
@@ -583,16 +588,33 @@ module NewRelic
       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
+    # This method returns a string suitable for inclusion in a page - known as
+    # 'manual instrumentation' for Real User Monitoring. Can return either a
+    # script tag with associated javascript, or in the case of disabled Real
+    # User Monitoring, an empty string
+    #
+    # This is the header string - it should be placed as high in the page as is
+    # reasonably possible - that is, before any style or javascript inclusions,
+    # but after any header-related meta tags
+    #
+    # In previous agents there was a corresponding footer required, but all the
+    # work is now done by this single method.
+    #
+    # @api public
     #
     def browser_timing_header
-      agent.browser_timing_header
+      agent.javascript_instrumentor.browser_timing_header
     end
 
-    # Returns a Javascript string which should be injected into the very bottom of the response body
+    # In previous agent releases, this method was required for manual RUM
+    # instrumentation. That work is now all done by the browser_timing_header
+    # method, but this is left for compatibility.
+    #
+    # @api public
+    # @deprecated
     #
     def browser_timing_footer
-      agent.browser_timing_footer
+      ""
     end
 
     def_delegator :'NewRelic::Agent::PipeChannelManager', :register_report_channel

data/lib/new_relic/agent/agent.rb

@@ -19,6 +19,7 @@ require 'new_relic/agent/event_listener'
 require 'new_relic/agent/cross_app_monitor'
 require 'new_relic/agent/request_sampler'
 require 'new_relic/agent/sampler_collection'
+require 'new_relic/agent/javascript_instrumentor'
 require 'new_relic/environment_report'
 
 module NewRelic
@@ -38,8 +39,6 @@ module NewRelic
           @service = NewRelic::Agent::NewRelicService.new
         end
 
-        @launch_time = Time.now
-
         @events                = NewRelic::Agent::EventListener.new
         @stats_engine          = NewRelic::Agent::StatsEngine.new
         @transaction_sampler   = NewRelic::Agent::TransactionSampler.new
@@ -50,6 +49,7 @@ module NewRelic
         @transaction_rules     = NewRelic::Agent::RulesEngine.new
         @request_sampler       = NewRelic::Agent::RequestSampler.new(@events)
         @harvest_samplers      = NewRelic::Agent::SamplerCollection.new(@events)
+        @javascript_instrumentor = NewRelic::Agent::JavascriptInstrumentor.new(@events)
 
         @connect_state      = :pending
         @connect_attempts   = 0
@@ -86,10 +86,8 @@ module NewRelic
         attr_reader :harvest_samplers
         # whether we should record raw, obfuscated, or no sql
         attr_reader :record_sql
-        # a configuration for the Real User Monitoring system -
-        # handles things like static setup of the header for inclusion
-        # into pages
-        attr_reader :beacon_configuration
+        # builder for JS agent scripts to inject
+        attr_reader :javascript_instrumentor
         # cross application tracing ids and encoding
         attr_reader :cross_process_id
         attr_reader :cross_app_encoding_bytes
@@ -185,7 +183,7 @@ module NewRelic
           reset_objects_with_locks
 
           # Clear out stats that are left over from parent process
-          reset_stats
+          drop_buffered_data
 
           generate_environment_report unless @service.is_a?(NewRelic::Agent::PipeService)
           start_worker_thread(options)
@@ -499,17 +497,20 @@ module NewRelic
           log_version_and_pid
         end
 
-        # Clear out the metric data, errors, and transaction traces,
-        # making sure the agent is in a fresh state
-        def reset_stats
-          @stats_engine.reset_stats
+        # Clear out the metric data, errors, and transaction traces, etc.
+        def drop_buffered_data
+          @stats_engine.reset!
           @error_collector.reset!
           @transaction_sampler.reset!
           @request_sampler.reset!
           @sql_sampler.reset!
-          @launch_time = Time.now
         end
 
+        # Deprecated, and not part of the public API, but here for backwards
+        # compatibility because some 3rd-party gems call it.
+        # @deprecated
+        def reset_stats; drop_buffered_data; end
+
         # Clear out state for any objects that we know lock from our parents
         # This is necessary for cases where we're in a forked child and Ruby
         # might be holding locks for background thread that aren't there anymore.
@@ -553,10 +554,12 @@ module NewRelic
             harvest_lock.unlock if harvest_lock.locked?
           end
 
-          # Creates the worker loop and loads it with the instructions
-          # it should run every @report_period seconds
+          def create_worker_loop
+            WorkerLoop.new
+          end
+
           def create_and_run_worker_loop
-            @worker_loop = WorkerLoop.new
+            @worker_loop = create_worker_loop
             @worker_loop.run(Agent.config[:data_report_period]) do
               transmit_data
             end
@@ -567,7 +570,7 @@ module NewRelic
           # waits a while to reconnect.
           def handle_force_restart(error)
             ::NewRelic::Agent.logger.debug error.message
-            reset_stats
+            drop_buffered_data
             @service.reset_metric_id_cache if @service
             @connect_state = :pending
             sleep 30
@@ -794,8 +797,6 @@ module NewRelic
 
             # If you're adding something else here to respond to the server-side config,
             # use Agent.instance.events.subscribe(:finished_configuring) callback instead!
-
-            @beacon_configuration = BeaconConfiguration.new
           end
 
           # Logs when we connect to the server, for debugging purposes
@@ -893,39 +894,60 @@ module NewRelic
           control.root
         end
 
-        # calls the busy harvester and collects timeslice data to
-        # send later
-        def harvest_timeslice_data
-          NewRelic::Agent::BusyCalculator.harvest_busy
-          @stats_engine.harvest
+        # Harvests data from the given container, sends it to the named endpoint
+        # on the service, and automatically merges back in upon a recoverable
+        # failure.
+        #
+        # The given container should respond to:
+        #
+        #  #harvest!
+        #    returns an enumerable collection of data items to be sent to the
+        #    collector.
+        #
+        #  #reset!
+        #    drop any stored data and reset to a clean state.
+        #
+        #  #merge!(items)
+        #    merge the given items back into the internal buffer of the
+        #    container, so that they may be harvested again later.
+        #  
+        def harvest_and_send_from_container(container, endpoint)
+          items = harvest_from_container(container, endpoint)
+          send_data_to_endpoint(endpoint, items, container) unless items.empty?
         end
 
-        def harvest_and_send_timeslice_data
-          timeslices = harvest_timeslice_data
+        def harvest_from_container(container, endpoint)
+          items = []
           begin
-            @service.metric_data(timeslices)
+            items = container.harvest!
+          rescue => e
+            NewRelic::Agent.logger.error("Failed to harvest #{endpoint} data, resetting. Error: ", e)
+            container.reset!
+          end
+          items
+        end
+
+        def send_data_to_endpoint(endpoint, items, container)
+          NewRelic::Agent.logger.debug("Sending #{items.size} items to #{endpoint}")
+          begin
+            @service.send(endpoint, items)
+          rescue ForceRestartException, ForceDisconnectException
+            raise
           rescue UnrecoverableServerException => e
-            ::NewRelic::Agent.logger.debug e.message
+            NewRelic::Agent.logger.warn("#{endpoint} data was rejected by remote service, discarding. Error: ", e)
           rescue => e
-            NewRelic::Agent.logger.info("Failed to send timeslice data, trying again later. Error:", e)
-            @stats_engine.merge!(timeslices)
+            NewRelic::Agent.logger.info("Unable to send #{endpoint} data, will try again later. Error: ", e)
+            container.merge!(items)
           end
         end
 
+        def harvest_and_send_timeslice_data
+          NewRelic::Agent::BusyCalculator.harvest_busy
+          harvest_and_send_from_container(@stats_engine, :metric_data)
+        end
+
         def harvest_and_send_slowest_sql
-          # FIXME add the code to try to resend if our connection is down
-          sql_traces = @sql_sampler.harvest
-          unless sql_traces.empty?
-            ::NewRelic::Agent.logger.debug "Sending (#{sql_traces.size}) sql traces"
-            begin
-              @service.sql_trace_data(sql_traces)
-            rescue UnrecoverableServerException => e
-              ::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)
-            end
-          end
+          harvest_and_send_from_container(@sql_sampler, :sql_trace_data)
         end
 
         # This handles getting the transaction traces and then sending
@@ -935,89 +957,40 @@ module NewRelic
         # segments' execution times exceed our threshold (to avoid
         # unnecessary overhead of running explains on fast queries.)
         def harvest_and_send_transaction_traces
-          traces = @transaction_sampler.harvest
-          unless traces.empty?
-            begin
-              send_transaction_traces(traces)
-            rescue UnrecoverableServerException => e
-              # 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
-        end
-
-        def send_transaction_traces(traces)
-          start_time = Time.now
-          ::NewRelic::Agent.logger.debug "Sending (#{traces.length}) transaction traces"
-
-          options = {}
-          unless NewRelic::Agent::Database.record_sql_method == :off
-            options[:record_sql] = NewRelic::Agent::Database.record_sql_method
-          end
-
-          if Agent.config[:'transaction_tracer.explain_enabled']
-            options[:explain_sql] = Agent.config[:'transaction_tracer.explain_threshold']
-          end
-
-          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"
+          harvest_and_send_from_container(@transaction_sampler, :transaction_sample_data)
         end
 
-        def harvest_and_send_for_agent_commands(disconnecting=false)
-          data = @agent_command_router.harvest_data_to_send(disconnecting)
-          data.each do |service_method, payload|
-            @service.send(service_method, payload)
-          end
+        def harvest_and_send_for_agent_commands
+          harvest_and_send_from_container(@agent_command_router, :profile_data)
         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
         def harvest_and_send_errors
-          errors = @error_collector.harvest_errors
-          if errors && !errors.empty?
-            ::NewRelic::Agent.logger.debug "Sending #{errors.length} errors"
-            begin
-              @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
-          end
+          harvest_and_send_from_container(@error_collector, :error_data)
         end
 
-        # Fetch samples from the RequestSampler and send them.
         def harvest_and_send_analytic_event_data
-          samples = @request_sampler.harvest
-          begin
-            @service.analytic_event_data(samples) unless samples.empty?
-          rescue
-            @request_sampler.merge!(samples)
-            raise
-          end
+          harvest_and_send_from_container(@request_sampler, :analytic_event_data)
         end
 
         def check_for_and_handle_agent_commands
-          @agent_command_router.check_for_and_handle_agent_commands
+          begin
+            @agent_command_router.check_for_and_handle_agent_commands
+          rescue ForceRestartException, ForceDisconnectException
+            raise
+          rescue => e
+            NewRelic::Agent.logger.warn("Error during check_for_and_handle_agent_commands, will retry later: ", e)
+          end
         end
 
-        def transmit_data(disconnecting=false)
+        def transmit_data
           harvest_lock.synchronize do
-            transmit_data_already_locked(disconnecting)
+            transmit_data_already_locked
           end
         end
 
         # This method is expected to only be called with the harvest_lock
         # already held
-        def transmit_data_already_locked(disconnecting)
+        def transmit_data_already_locked
           now = Time.now
           ::NewRelic::Agent.logger.debug "Sending data to New Relic Service"
 
@@ -1030,19 +1003,8 @@ module NewRelic
             harvest_and_send_analytic_event_data
 
             check_for_and_handle_agent_commands
-            harvest_and_send_for_agent_commands(disconnecting)
-          end
-        rescue EOFError => e
-          ::NewRelic::Agent.logger.warn("EOFError after #{Time.now - now}s when transmitting data to New Relic Service.")
-          ::NewRelic::Agent.logger.debug(e)
-        rescue => e
-          retry_count ||= 0
-          retry_count += 1
-          if retry_count <= 1
-            ::NewRelic::Agent.logger.debug "retrying transmit_data after #{e}"
-            retry
+            harvest_and_send_for_agent_commands
           end
-          raise e
         ensure
           NewRelic::Agent::Database.close_connections
           duration = (Time.now - now).to_f
@@ -1062,7 +1024,9 @@ module NewRelic
           if connected?
             begin
               @service.request_timeout = 10
-              transmit_data(true)
+
+              @events.notify(:before_shutdown)
+              transmit_data
 
               if @connected_pid == $$ && !@service.kind_of?(NewRelic::Agent::NewRelicService)
                 ::NewRelic::Agent.logger.debug "Sending New Relic service agent run shutdown message"
@@ -1082,7 +1046,6 @@ module NewRelic
 
       extend ClassMethods
       include InstanceMethods
-      include BrowserMonitoring
     end
   end
 end