newrelic_rpm 3.0.1 → 3.1.0.beta1

data/CHANGELOG

@@ -1,6 +1,5 @@
-v3.0.1 
-  * Updated Real User Monitoring to reduce javascript size and improve
-    compatibility, fix a few known bugs
+v3.1.0
+  * Experimental support for aggregating data from short-running processes using NewRelic::Agent.load_data and NewRelic::Agent.save_data
 
 v3.0.0
   * Support for Real User Monitoring

data/README.rdoc

@@ -25,9 +25,9 @@ automatically in Rails applications.
 
 == Supported Environments
 
-* Ruby 1.8.6, 1.8.7 or 1.9.1, including REE
-* JRuby 1.3 minimum
-* Rails 1.2.6 or later for Production Mode
+* Ruby 1.8.6, 1.8.7, 1.9.1, or 1.9.2, including REE
+* JRuby 1.4 minimum
+* Rails 2.0 or later for Production Mode
 * Rails 2.2 or later for Developer Mode
 * Merb 1.0 or later
 * Sinatra

data/lib/new_relic/agent.rb

@@ -125,7 +125,7 @@ module NewRelic
       @agent
     end
 
-    def agent= new_instance #:nodoc:
+    def agent=(new_instance)#:nodoc:
       @agent = new_instance
     end
 
@@ -167,7 +167,7 @@ module NewRelic
     # (ie, RAILS_ENV) can be overridden with an :env argument.
     #
     def manual_start(options={})
-      raise unless Hash === options
+      raise "Options must be a hash" unless Hash === options
       NewRelic::Control.instance.init_plugin({ :agent_enabled => true, :sync_startup => true }.merge(options))
     end
 
@@ -204,8 +204,20 @@ module NewRelic
 
     # Shutdown the agent.  Call this before exiting.  Sends any queued data
     # and kills the background thread.
-    def shutdown
-      agent.shutdown
+    def shutdown(options = {})
+      agent.shutdown(options)
+    end
+
+    def save_data
+      NewRelic::DataSerialization.dump_to_file do |old_data|
+        agent.merge_data_from(old_data)
+        agent.serialize
+      end
+    end
+
+    def load_data
+      agent.merge_data_from(NewRelic::DataSerialization.load_from_file)
+      {:metrics => agent.stats_engine.metrics.length, :traces => agent.unsent_traces_size, :errors => agent.unsent_errors_size}
     end
 
     # Add instrumentation files to the agent.  The argument should be
@@ -214,7 +226,7 @@ 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.
-    def add_instrumentation file_pattern
+    def add_instrumentation(file_pattern)
       NewRelic::Control.instance.add_instrumentation file_pattern
     end
 
@@ -292,11 +304,11 @@ module NewRelic
     def is_execution_traced?
       Thread.current[:newrelic_untraced].nil? || Thread.current[:newrelic_untraced].last != false
     end
-    
+
     def is_transaction_traced?
       Thread::current[:record_tt] != false
     end
-    
+
     def is_sql_recorded?
       Thread::current[:record_sql] != false
     end

data/lib/new_relic/agent/agent.rb

@@ -64,6 +64,18 @@ module NewRelic
         attr_reader :url_rules
         attr_reader :beacon_configuration
 
+        def unsent_errors_size
+          @unsent_errors.length if @unsent_errors
+        end
+
+        def unsent_traces_size
+          @traces.length if @traces
+        end
+
+        def unsent_timeslice_data
+          @unsent_timeslice_data.keys.length
+        end
+
         def record_transaction(duration_seconds, options={})
           is_error = options['is_error'] || options['error_message'] || options['exception']
           metric = options['metric']
@@ -150,9 +162,11 @@ module NewRelic
         end
 
         # Attempt a graceful shutdown of the agent.
-        def shutdown
+        def shutdown(options={})
+          run_loop_before_exit = options.fetch(:force_send, false)
           return if not started?
           if @worker_loop
+            @worker_loop.run_task if run_loop_before_exit
             @worker_loop.stop
 
             log.debug "Starting Agent shutdown"
@@ -431,8 +445,9 @@ module NewRelic
           def create_and_run_worker_loop
             @worker_loop = WorkerLoop.new
             @worker_loop.run(@report_period) do
-              harvest_and_send_slowest_sample if @should_send_samples
-              harvest_and_send_errors if error_collector.enabled
+              NewRelic::Agent.load_data
+              harvest_and_send_errors
+              harvest_and_send_slowest_sample
               harvest_and_send_timeslice_data
             end
           end
@@ -662,6 +677,37 @@ module NewRelic
         end
         include Connect
 
+        def serialize
+          accumulator = []
+          accumulator[1] = harvest_transaction_traces if @transaction_sampler
+          accumulator[2] = harvest_errors if @error_collector
+          accumulator[0] = harvest_timeslice_data
+          accumulator
+        end
+
+        public :serialize
+
+        def merge_data_from(data)
+          metrics, transaction_traces, errors = data
+          @stats_engine.merge_data(metrics) if metrics
+          if transaction_traces
+            if @traces
+              @traces = @traces + transaction_traces
+            else
+              @traces = transaction_traces
+            end
+          end
+          if errors
+            if @unsent_errors
+              @unsent_errors = @unsent_errors + errors
+            else
+              @unsent_errors = errors
+            end
+          end
+        end
+
+        public :merge_data_from
+
         # Connect to the server and validate the license.  If successful,
         # @connected has true when finished.  If not successful, you can
         # keep calling this.  Return false if we could not establish a
@@ -715,32 +761,39 @@ module NewRelic
           $0 =~ /ApplicationSpawner|^unicorn\S* master/
         end
 
-        def harvest_and_send_timeslice_data
-
+        def harvest_timeslice_data(time=Time.now)
+          # this creates timeslices that are harvested below
           NewRelic::Agent::BusyCalculator.harvest_busy
 
-          now = Time.now
-          NewRelic::Agent.instance.stats_engine.get_stats_no_scope('Supportability/invoke_remote').record_data_point(0.0)
-          NewRelic::Agent.instance.stats_engine.get_stats_no_scope('Supportability/invoke_remote/metric_data').record_data_point(0.0)
-
           @unsent_timeslice_data ||= {}
           @unsent_timeslice_data = @stats_engine.harvest_timeslice_data(@unsent_timeslice_data, @metric_ids)
+          @unsent_timeslice_data
+        end
 
+        def fill_metric_id_cache(pairs_of_specs_and_ids)
+          Array(pairs_of_specs_and_ids).each do |metric_spec, metric_id|
+            @metric_ids[metric_spec] = metric_id
+          end
+        end
+
+        def harvest_and_send_timeslice_data
+          now = Time.now
+          NewRelic::Agent.instance.stats_engine.get_stats_no_scope('Supportability/invoke_remote').record_data_point(0.0)
+          NewRelic::Agent.instance.stats_engine.get_stats_no_scope('Supportability/invoke_remote/metric_data').record_data_point(0.0)
+          harvest_timeslice_data(now)
           begin
             # In this version of the protocol, we get back an assoc array of spec to id.
-            metric_ids = invoke_remote(:metric_data, @agent_id,
+            metric_specs_and_ids = invoke_remote(:metric_data, @agent_id,
                                        @last_harvest_time.to_f,
                                        now.to_f,
                                        @unsent_timeslice_data.values)
 
           rescue Timeout::Error
             # assume that the data was received. chances are that it was
-            metric_ids = nil
+            metric_specs_and_ids = []
           end
 
-          metric_ids.each do | spec, id |
-            @metric_ids[spec] = id
-          end if metric_ids
+          fill_metric_id_cache(metric_specs_and_ids)
 
           log.debug "#{now}: sent #{@unsent_timeslice_data.length} timeslices (#{@agent_id}) in #{Time.now - now} seconds"
 
@@ -754,9 +807,13 @@ module NewRelic
           # then the metric data is downsampled for another timeslices
         end
 
-        def harvest_and_send_slowest_sample
+        def harvest_transaction_traces
           @traces = @transaction_sampler.harvest(@traces, @slowest_transaction_threshold)
+          @traces
+        end
 
+        def harvest_and_send_slowest_sample
+          harvest_transaction_traces
           unless @traces.empty?
             now = Time.now
             log.debug "Sending (#{@traces.length}) transaction traces"
@@ -792,8 +849,13 @@ module NewRelic
           # sample.
         end
 
-        def harvest_and_send_errors
+        def harvest_errors
           @unsent_errors = @error_collector.harvest_errors(@unsent_errors)
+          @unsent_errors
+        end
+
+        def harvest_and_send_errors
+          harvest_errors
           if @unsent_errors && @unsent_errors.length > 0
             log.debug "Sending #{@unsent_errors.length} errors"
             begin
@@ -925,15 +987,17 @@ module NewRelic
           raise NewRelic::Agent::ServerConnectionException, "Recoverable error connecting to the server: #{e}"
         ensure
           NewRelic::Agent.instance.stats_engine.get_stats_no_scope('Supportability/invoke_remote').record_data_point((Time.now - now).to_f)
-          NewRelic::Agent.instance.stats_engine.get_stats_no_scope('Supportability/invoke_remote/' + method.to_s).record_data_point((Time.now - now).to_f)          
+          NewRelic::Agent.instance.stats_engine.get_stats_no_scope('Supportability/invoke_remote/' + method.to_s).record_data_point((Time.now - now).to_f)
         end
 
         def graceful_disconnect
           if @connected
             begin
               @request_timeout = 10
-              log.debug "Flushing unsent metric data to server"
-              @worker_loop.run_task
+#              log.debug "Flushing unsent metric data to server"
+#              harvest_and_send_timeslice_data
+              log.debug "Serializing agent data to disk"
+              NewRelic::Agent.save_data
               if @connected_pid == $$
                 log.debug "Sending RPM service agent run shutdown message"
                 invoke_remote :shutdown, @agent_id, Time.now.to_f

data/lib/new_relic/agent/beacon_configuration.rb

@@ -2,23 +2,19 @@ module NewRelic
   module Agent
     class BeaconConfiguration
       attr_reader :browser_timing_header
-      attr_reader :browser_timing_static_footer
       attr_reader :application_id
       attr_reader :browser_monitoring_key
       attr_reader :beacon
       attr_reader :rum_enabled
       attr_reader :license_bytes
 
-      JS_HEADER = "<script>var NREUMQ=[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);</script>"
-
       def initialize(connect_data)
         @browser_monitoring_key = connect_data['browser_key']
         @application_id = connect_data['application_id']
         @beacon = connect_data['beacon']
         @rum_enabled = connect_data['rum.enabled']
         @rum_enabled = true if @rum_enabled.nil?
-        @browser_timing_header = build_browser_timing_header
-        @browser_timing_static_footer = build_load_file_js(connect_data) 
+        @browser_timing_header = build_browser_timing_header(connect_data)
       end
 
       def license_bytes
@@ -29,22 +25,22 @@ module NewRelic
         @license_bytes
       end
 
-      def build_load_file_js(connect_data)
+      def load_file_js(connect_data)
         return "" unless connect_data.fetch('rum.load_episodes_file', true)
 
         episodes_url = connect_data.fetch('episodes_url', '')
-        "(function(){var d=document;var e=d.createElement(\"script\");e.async=true;e.src=\"#{episodes_url}\";var s=d.getElementsByTagName(\"script\")[0];s.parentNode.insertBefore(e,s);})();"
+        "(function(){var d=document;var e=d.createElement(\"script\");e.type=\"text/javascript\";e.async=true;e.src=\"#{episodes_url}\";var s=d.getElementsByTagName(\"script\")[0];s.parentNode.insertBefore(e,s);})()"
       end
 
-      def javascript_header
-        JS_HEADER.dup
+      def basic_javascript(connect_data)
+        "<script>var NREUMQ=[];NREUMQ.push([\"mark\",\"firstbyte\",new Date().getTime()]);#{load_file_js(connect_data)}</script>"
       end
 
-      def build_browser_timing_header
+      def build_browser_timing_header(connect_data)
         return "" if !@rum_enabled
         return "" if @browser_monitoring_key.nil?
-        
-        value = javascript_header
+
+        value = basic_javascript(connect_data)
         if value.respond_to?(:html_safe)
           value.html_safe
         else

data/lib/new_relic/agent/browser_monitoring.rb

@@ -7,10 +7,10 @@ module NewRelic
       def browser_timing_header
         return "" if NewRelic::Agent.instance.beacon_configuration.nil?
         return "" if !NewRelic::Agent.is_transaction_traced? || !NewRelic::Agent.is_execution_traced?
-        
+
         NewRelic::Agent.instance.beacon_configuration.browser_timing_header
       end
-      
+
       def browser_timing_footer
         config = NewRelic::Agent.instance.beacon_configuration
         return "" if config.nil? || !config.rum_enabled || config.browser_monitoring_key.nil?
@@ -25,8 +25,8 @@ module NewRelic
           config = NewRelic::Agent.instance.beacon_configuration
           application_id = config.application_id
           beacon = config.beacon
-          license_key = config.browser_monitoring_key          
-          
+          license_key = config.browser_monitoring_key
+
           footer_js_string(beacon, license_key, application_id)
         else
           ''
@@ -36,7 +36,7 @@ module NewRelic
       def browser_monitoring_transaction_name
         Thread.current[:newrelic_most_recent_transaction] || "<unknown>"
       end
-      
+
       def browser_monitoring_start_time
         Thread.current[:newrelic_start_time]
       end
@@ -56,7 +56,7 @@ module NewRelic
 
       def footer_js_string(beacon, license_key, application_id)
         obfuscated_transaction_name = obfuscate(browser_monitoring_transaction_name)
-        html_safe_if_needed("<script>#{NewRelic::Agent.instance.beacon_configuration.browser_timing_static_footer}NREUMQ.push([\"nrf2\",\"#{beacon}\",\"#{license_key}\",#{application_id},\"#{obfuscated_transaction_name}\",#{browser_monitoring_queue_time},#{browser_monitoring_app_time},new Date().getTime()])</script>")
+        html_safe_if_needed("<script type=\"text/javascript\" charset=\"utf-8\">NREUMQ.push([\"nrf2\",\"#{beacon}\",\"#{license_key}\",#{application_id},\"#{obfuscated_transaction_name}\",#{browser_monitoring_queue_time},#{browser_monitoring_app_time}])</script>")
       end
 
       def html_safe_if_needed(string)
@@ -66,7 +66,7 @@ module NewRelic
           string
         end
       end
-      
+
       def obfuscate(text)
         obfuscated = ""
         key_bytes = NewRelic::Agent.instance.beacon_configuration.license_bytes
@@ -76,7 +76,7 @@ module NewRelic
           index+=1
         }
 
-        [obfuscated].pack("m0").gsub("\n", '')
+        [obfuscated].pack("m0").chomp
       end
     end
   end

data/lib/new_relic/agent/error_collector.rb

@@ -143,16 +143,16 @@ module NewRelic
         }
       end
 
-      def over_queue_limit?(exception)
+      def over_queue_limit?(message)
         over_limit = (@errors.length >= MAX_ERROR_QUEUE_LENGTH)
-        log.warn("The error reporting queue has reached #{MAX_ERROR_QUEUE_LENGTH}. The error detail for this and subsequent errors will not be transmitted to RPM until the queued errors have been sent: #{exception}") if over_limit
+        log.warn("The error reporting queue has reached #{MAX_ERROR_QUEUE_LENGTH}. The error detail for this and subsequent errors will not be transmitted to RPM until the queued errors have been sent: #{message}") if over_limit
         over_limit
       end
 
 
-      def add_to_error_queue(noticed_error, exception)
+      def add_to_error_queue(noticed_error)
         @lock.synchronize do
-          @errors << noticed_error unless over_queue_limit?(exception)
+          @errors << noticed_error unless over_queue_limit?(noticed_error.message)
         end
       end
     end
@@ -173,7 +173,7 @@ module NewRelic
       return if should_exit_notice_error?(exception)
       action_path     = fetch_from_options(options, :metric, (NewRelic::Agent.instance.stats_engine.scope_name || ''))
       exception_options = error_params_from_options(options).merge(exception_info(exception))
-      add_to_error_queue(NewRelic::NoticedError.new(action_path, exception_options, exception), exception)
+      add_to_error_queue(NewRelic::NoticedError.new(action_path, exception_options, exception))
       exception
     rescue Exception => e
       log.error("Error capturing an error, yodawg. #{e}")
@@ -181,16 +181,16 @@ module NewRelic
 
     # Get the errors currently queued up.  Unsent errors are left
     # over from a previous unsuccessful attempt to send them to the server.
-    # We first clear out all unsent errors before sending the newly queued errors.
     def harvest_errors(unsent_errors)
-      if unsent_errors && !unsent_errors.empty?
-        return unsent_errors
-      else
-        @lock.synchronize do
-          errors = @errors
-          @errors = []
-          return errors
+      @lock.synchronize do
+        errors = @errors
+        @errors = []
+
+        if unsent_errors && !unsent_errors.empty?
+          errors = unsent_errors + errors
         end
+
+        errors
       end
     end
 

data/lib/new_relic/agent/instrumentation.rb

@@ -0,0 +1,9 @@
+require 'new_relic/agent'
+# stub module that contains instrumentation defined in the
+# instrumentation directory
+module NewRelic
+  module Agent
+    module Instrumentation
+    end
+  end
+end

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

@@ -234,7 +234,7 @@ module NewRelic
 
           # Skip instrumentation based on the value of 'do_not_trace' and if
           # we aren't calling directly with a block.
-          if !block_given? && _is_filtered?('do_not_trace')
+          if !block_given? && do_not_trace?
             # Also ignore all instrumentation in the call sequence
             NewRelic::Agent.disable_all_tracing do
               return perform_action_without_newrelic_trace(*args)
@@ -263,7 +263,7 @@ module NewRelic
             NewRelic::Agent::BusyCalculator.dispatcher_finish
             # Look for a metric frame in the thread local and process it.
             # Clear the thread local when finished to ensure it only gets called once.
-            frame_data.record_apdex unless _is_filtered?('ignore_apdex')
+            frame_data.record_apdex unless ignore_apdex?
 
             frame_data.pop
           end
@@ -277,6 +277,14 @@ module NewRelic
           self.respond_to?(:request) && self.request.respond_to?(:headers) && self.request.headers
         end
 
+        def do_not_trace?
+          _is_filtered?('do_not_trace')
+        end
+
+        def ignore_apdex?
+          _is_filtered?('ignore_apdex')
+        end
+
         private
 
         # Profile the instrumented call.  Dev mode only.  Experimental.