newrelic_rpm 3.6.7.159 → 3.6.8.164

data/CHANGELOG

@@ -1,5 +1,19 @@
 # New Relic Ruby Agent Release Notes #
 
+## v3.6.8 ##
+
+  * X-Ray Sessions support
+
+  X-Ray Sessions provide more targeted transaction trace samples and thread
+  profiling for web transactions. For full details see our X-Ray sessions
+  documentation at https://newrelic.com/docs/site/xray-sessions.
+
+  * CPU metrics re-enabled for JRuby >= 1.7.0
+
+  To work around a JRuby bug, the Ruby agent stopped gathering CPU metrics on
+  that platform.  With the bug fixed, the agent can gather those metrics again.
+  Thanks Bram de Vries for the contribution!
+
 ## v3.6.7 ##
 
   * Resque-pool support

data/lib/new_relic/agent/agent.rb

@@ -15,7 +15,6 @@ require 'new_relic/agent/pipe_service'
 require 'new_relic/agent/configuration/manager'
 require 'new_relic/agent/database'
 require 'new_relic/agent/commands/agent_command_router'
-require 'new_relic/agent/commands/thread_profiler'
 require 'new_relic/agent/event_listener'
 require 'new_relic/agent/cross_app_monitor'
 require 'new_relic/agent/request_sampler'
@@ -45,8 +44,7 @@ module NewRelic
         @stats_engine          = NewRelic::Agent::StatsEngine.new
         @transaction_sampler   = NewRelic::Agent::TransactionSampler.new
         @sql_sampler           = NewRelic::Agent::SqlSampler.new
-        @thread_profiler       = NewRelic::Agent::Commands::ThreadProfiler.new
-        @agent_command_router  = NewRelic::Agent::Commands::AgentCommandRouter.new(@thread_profiler)
+        @agent_command_router  = NewRelic::Agent::Commands::AgentCommandRouter.new(@events)
         @cross_app_monitor     = NewRelic::Agent::CrossAppMonitor.new(@events)
         @error_collector       = NewRelic::Agent::ErrorCollector.new
         @transaction_rules     = NewRelic::Agent::RulesEngine.new
@@ -59,6 +57,7 @@ module NewRelic
         @environment_report = nil
 
         @last_harvest_time = Time.now
+        @harvest_lock = Mutex.new
         @obfuscator = lambda {|sql| NewRelic::Agent::Database.default_sql_obfuscator(sql) }
       end
 
@@ -82,8 +81,7 @@ module NewRelic
         # the transaction sampler that handles recording transactions
         attr_reader :transaction_sampler
         attr_reader :sql_sampler
-        # begins a thread profile session when instructed by agent commands
-        attr_reader :thread_profiler
+        # manages agent commands we receive from the collector, and the handlers
         attr_reader :agent_command_router
         # error collector is a simple collection of recorded errors
         attr_reader :error_collector
@@ -109,6 +107,7 @@ module NewRelic
         # 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
@@ -557,22 +556,12 @@ module NewRelic
             ::NewRelic::Agent.logger.debug "Running worker loop"
           end
 
-          # Accessor for the harvest lock
-          def harvest_lock
-            return nil if @worker_loop.nil?
-            @worker_loop.lock
-          end
-
           # Synchronize with the harvest loop. If the harvest thread has taken
           # a lock (DNS lookups, backticks, agent-owned locks, etc), and we
           # fork while locked, this can deadlock child processes. For more
           # details, see https://github.com/resque/resque/issues/1101
           def synchronize_with_harvest
-            if harvest_lock
-              harvest_lock.synchronize do
-                yield
-              end
-            else
+            harvest_lock.synchronize do
               yield
             end
           end
@@ -622,9 +611,12 @@ module NewRelic
 
           # Handles an unknown error in the worker thread by logging
           # it and disconnecting the agent, since we are now in an
-          # unknown state
+          # unknown state.
           def handle_other_error(error)
-            ::NewRelic::Agent.logger.error "Terminating worker loop.", error
+            ::NewRelic::Agent.logger.error "Unhandled error in worker thread, disconnecting this agent process:"
+            # These errors are fatal (that is, they will prevent the agent from
+            # reporting entirely), so we really want backtraces when they happen
+            ::NewRelic::Agent.logger.log_exception(:error, error)
             disconnect
           end
 
@@ -921,7 +913,7 @@ module NewRelic
           handle_license_error(e)
         rescue NewRelic::Agent::UnrecoverableAgentException => e
           handle_unrecoverable_agent_error(e)
-        rescue Timeout::Error, StandardError => e
+        rescue Timeout::Error => e
           log_error(e)
           if opts[:keep_retrying]
             note_connect_failure
@@ -931,6 +923,8 @@ module NewRelic
           else
             disconnect
           end
+        rescue StandardError => e
+          handle_other_error(e)
         end
 
         # Who am I? Well, this method can tell you your hostname.
@@ -984,7 +978,6 @@ module NewRelic
         # transaction threshold
         def harvest_transaction_traces
           @traces = @transaction_sampler.harvest(@traces)
-          @traces
         end
 
         def harvest_and_send_slowest_sql
@@ -1045,14 +1038,10 @@ module NewRelic
           ::NewRelic::Agent.logger.debug "Sent slowest sample (#{@service.agent_id}) in #{Time.now - start_time} seconds"
         end
 
-        def harvest_and_send_thread_profile(disconnecting=false)
-          @thread_profiler.stop(true) if disconnecting
-
-          if @thread_profiler.finished?
-            profile = @thread_profiler.harvest
-
-            ::NewRelic::Agent.logger.debug "Sending thread profile #{profile.profile_id}"
-            @service.profile_data(profile)
+        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
         end
 
@@ -1087,16 +1076,28 @@ module NewRelic
 
         # Fetch samples from the RequestSampler and send them.
         def harvest_and_send_analytic_event_data
-          samples = @request_sampler.samples
-          @service.analytic_event_data(samples) unless samples.empty?
-          @request_sampler.reset
+          samples = @request_sampler.harvest
+          begin
+            @service.analytic_event_data(samples) unless samples.empty?
+          rescue
+            @request_sampler.merge(samples)
+            raise
+          end
         end
 
-        def handle_agent_commands
-          @agent_command_router.handle_agent_commands
+        def check_for_and_handle_agent_commands
+          @agent_command_router.check_for_and_handle_agent_commands
         end
 
         def transmit_data(disconnecting=false)
+          harvest_lock.synchronize do
+            transmit_data_already_locked(disconnecting)
+          end
+        end
+
+        # This method is expected to only be called with the harvest_lock
+        # already held
+        def transmit_data_already_locked(disconnecting)
           now = Time.now
           ::NewRelic::Agent.logger.debug "Sending data to New Relic Service"
 
@@ -1108,8 +1109,8 @@ module NewRelic
             harvest_and_send_timeslice_data
             harvest_and_send_analytic_event_data
 
-            handle_agent_commands
-            harvest_and_send_thread_profile(disconnecting)
+            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.")
@@ -1128,6 +1129,8 @@ module NewRelic
           @stats_engine.record_metrics('Supportability/Harvest', duration)
         end
 
+        private :transmit_data_already_locked
+
         # This method contacts the server to send remaining data and
         # let the server know that the agent is shutting down - this
         # allows us to do things like accurately set the end of the

data/lib/new_relic/agent/agent_logger.rb

@@ -16,7 +16,6 @@ module NewRelic
         gather_startup_logs
       end
 
-
       def fatal(*msgs)
         format_and_send(:fatal, msgs)
       end
@@ -120,15 +119,15 @@ module NewRelic
       end
 
       LOG_LEVELS = {
-        "debug" => Logger::DEBUG,
-        "info"  => Logger::INFO,
-        "warn"  => Logger::WARN,
-        "error" => Logger::ERROR,
-        "fatal" => Logger::FATAL,
+        "debug" => ::Logger::DEBUG,
+        "info"  => ::Logger::INFO,
+        "warn"  => ::Logger::WARN,
+        "error" => ::Logger::ERROR,
+        "fatal" => ::Logger::FATAL,
       }
 
       def self.log_level_for(level)
-        LOG_LEVELS.fetch(level.to_s.downcase, Logger::INFO)
+        LOG_LEVELS.fetch(level.to_s.downcase, ::Logger::INFO)
       end
 
       def set_log_format!
@@ -143,46 +142,6 @@ module NewRelic
       end
     end
 
-    # Base class for startup logging and testing in multiverse
-    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 dump(logger)
-        messages.each do |msg|
-          logger.send(msg[0], msg[1])
-        end
-        messages.clear
-      end
-    end
-
     # In an effort to not lose messages during startup, we trap them in memory
     # The real logger will then dump its contents out when it arrives.
     class StartupLogger < MemoryLogger

data/lib/new_relic/agent/beacon_configuration.rb

@@ -28,10 +28,16 @@ module NewRelic
       # Creates a new browser configuration data. Argument is a hash
       # of configuration values from the server
       def initialize
-        @browser_timing_header = build_browser_timing_header
-        ::NewRelic::Agent.logger.debug("Browser timing header: #{@browser_timing_header.inspect}")
-        @browser_timing_static_footer = build_load_file_js
-        ::NewRelic::Agent.logger.debug("Browser timing static footer: #{@browser_timing_static_footer.inspect}")
+        if Agent.config[:js_errors_beta] && Agent.config[:js_agent_loader]
+          ::NewRelic::Agent.logger.debug("Beta JS errors functionality enabled")
+          ::NewRelic::Agent.logger.debug("JS agent loader version: #{Agent.config[:js_agent_loader_version]}")
+        else
+          @browser_timing_header = build_browser_timing_header
+          ::NewRelic::Agent.logger.debug("Browser timing header: #{@browser_timing_header.inspect}")
+          @browser_timing_static_footer = build_load_file_js
+          ::NewRelic::Agent.logger.debug("Browser timing static footer: #{@browser_timing_static_footer.inspect}")
+        end
+
         if Agent.config[:'rum.jsonp']
           ::NewRelic::Agent.logger.debug("Real User Monitoring is using JSONP protocol")
           @finish_command = 'nrfj'

data/lib/new_relic/agent/browser_monitoring.rb

@@ -97,29 +97,6 @@ module NewRelic
         NewRelic::Agent::TransactionState.get.timings
       end
 
-      def insert_mobile_response_header(request, response)
-        if mobile_header_found_in?(request) &&
-            NewRelic::Agent.instance.beacon_configuration
-
-          config = NewRelic::Agent.instance.beacon_configuration
-
-          response['X-NewRelic-Beacon-Url'] = beacon_url(request)
-
-          payload = %[ ["#{Agent.config[:application_id]}","#{obfuscate(config, browser_monitoring_transaction_name)}",#{current_timings.queue_time_in_millis},#{current_timings.app_time_in_millis}] ]
-          response['X-NewRelic-App-Server-Metrics'] = payload
-        end
-      end
-
-      def mobile_header_found_in?(request)
-        headers = ['HTTP_X_NEWRELIC_MOBILE_TRACE', 'X_NEWRELIC_MOBILE_TRACE',
-                   'X-NewRelic-Mobile-Trace']
-        headers.inject(false){|i,m| i || (request.env[m] == 'true')}
-      end
-
-      def beacon_url(request)
-        "#{request.scheme || 'http'}://#{Agent.config[:beacon]}/mobile/1/#{Agent.config[:browser_key]}"
-      end
-
       private
 
       # Check whether RUM header and footer should be generated.  Log the
@@ -176,26 +153,55 @@ module NewRelic
         return NewRelic::Agent::TransactionState.get.request_token
       end
 
+      def use_beta_js_agent?
+        return Agent.config[:js_errors_beta] && Agent.config[:js_agent_loader]
+      end
+
       # NOTE: This method may be overridden for internal prototyping, so should
       # remain stable.
       def header_js_string
-        NewRelic::Agent.instance.beacon_configuration.browser_timing_header
+        if (use_beta_js_agent?)
+          html_safe_if_needed("\n<script type=\"text/javascript\">#{Agent.config[:js_agent_loader]}</script>")
+        else
+          NewRelic::Agent.instance.beacon_configuration.browser_timing_header
+        end
       end
 
       # NOTE: This method may be overridden for internal prototyping, so should
       # remain stable.
       def footer_js_string(config)
-        obfuscated_transaction_name = obfuscate(config, browser_monitoring_transaction_name)
+        if (use_beta_js_agent?)
+          js_data = {
+            'txnParam' => config.finish_command,
+            'beacon' => NewRelic::Agent.config[:beacon],
+            'errorBeacon' => NewRelic::Agent.config[:error_beacon],
+            'licenseKey' => NewRelic::Agent.config[:browser_key],
+            'applicationID' => NewRelic::Agent.config[:application_id],
+            'transactionName' => obfuscate(config, browser_monitoring_transaction_name),
+            'queueTime' => current_timings.queue_time_in_millis,
+            'applicationTime' => current_timings.app_time_in_millis,
+            'ttGuid' => tt_guid,
+            'agentToken' => tt_token,
+            'user' => obfuscate(config, transaction_attribute(:user)),
+            'account' => obfuscate(config, transaction_attribute(:account)),
+            'product' => obfuscate(config, transaction_attribute(:product)),
+            'agent' => NewRelic::Agent.config[:js_agent_file]
+          }
+
+          html_safe_if_needed("\n<script type=\"text/javascript\">window.NREUM||(NREUM={});NREUM.info=#{NewRelic.json_dump(js_data)}</script>")
+        else
+          obfuscated_transaction_name = obfuscate(config, browser_monitoring_transaction_name)
 
-        user = obfuscate(config, transaction_attribute(:user))
-        account = obfuscate(config, transaction_attribute(:account))
-        product = obfuscate(config, transaction_attribute(:product))
+          user = obfuscate(config, transaction_attribute(:user))
+          account = obfuscate(config, transaction_attribute(:account))
+          product = obfuscate(config, transaction_attribute(:product))
 
-        # This is slightly varied from other agents' RUM footer to ensure that
-        # NREUMQ is defined. Our experimental header placement has some holes
-        # where it could end up in a comment and not define NREUMQ as the footer
-        # assumes. We protect against that here.
-        html_safe_if_needed(%'<script type="text/javascript">if (typeof NREUMQ !== "undefined") { #{config.browser_timing_static_footer}NREUMQ.push(["#{config.finish_command}","#{Agent.config[:beacon]}","#{Agent.config[:browser_key]}","#{Agent.config[:application_id]}","#{obfuscated_transaction_name}",#{current_timings.queue_time_in_millis},#{current_timings.app_time_in_millis},new Date().getTime(),"#{tt_guid}","#{tt_token}","#{user}","#{account}","#{product}"]);}</script>')
+          # This is slightly varied from other agents' RUM footer to ensure that
+          # NREUMQ is defined. Our experimental header placement has some holes
+          # where it could end up in a comment and not define NREUMQ as the footer
+          # assumes. We protect against that here.
+          html_safe_if_needed(%'<script type="text/javascript">if (typeof NREUMQ !== "undefined") { #{config.browser_timing_static_footer}NREUMQ.push(["#{config.finish_command}","#{Agent.config[:beacon]}","#{Agent.config[:browser_key]}","#{Agent.config[:application_id]}","#{obfuscated_transaction_name}",#{current_timings.queue_time_in_millis},#{current_timings.app_time_in_millis},new Date().getTime(),"#{tt_guid}","#{tt_token}","#{user}","#{account}","#{product}"]);}</script>')
+        end
       end
 
       def html_safe_if_needed(string)

data/lib/new_relic/agent/commands/agent_command.rb

@@ -8,10 +8,10 @@ module NewRelic
       class AgentCommand
         attr_reader :id, :name, :arguments
 
-        def initialize(collector_command)
-          @id        = collector_command[0]
-          @name      = collector_command[1]["name"]
-          @arguments = collector_command[1]["arguments"]
+        def initialize(raw_collector_command)
+          @id        = raw_collector_command[0]
+          @name      = raw_collector_command[1]["name"]
+          @arguments = raw_collector_command[1]["arguments"]
         end
       end
     end

data/lib/new_relic/agent/commands/agent_command_router.rb

@@ -9,6 +9,8 @@
 # like the ThreadProfiler, so it's simpler to just keep it together here.
 
 require 'new_relic/agent/commands/agent_command'
+require 'new_relic/agent/commands/xray_session_collection'
+require 'new_relic/agent/threading/backtrace_service'
 
 module NewRelic
   module Agent
@@ -16,32 +18,91 @@ module NewRelic
       class AgentCommandRouter
         attr_reader :handlers
 
-        def initialize(thread_profiler)
+        attr_accessor :thread_profiler_session, :backtrace_service,
+                      :xray_session_collection
+
+        def initialize(event_listener=nil)
           @handlers    = Hash.new { |*| Proc.new { |cmd| self.unrecognized_agent_command(cmd) } }
-          @handlers['start_profiler'] = Proc.new { |cmd| thread_profiler.handle_start_command(cmd) }
-          @handlers['stop_profiler']  = Proc.new { |cmd| thread_profiler.handle_stop_command(cmd) }
+
+          @backtrace_service = Threading::BacktraceService.new(event_listener)
+
+          @thread_profiler_session = ThreadProfilerSession.new(@backtrace_service)
+          @xray_session_collection = XraySessionCollection.new(@backtrace_service, event_listener)
+
+          @handlers['start_profiler'] = Proc.new { |cmd| thread_profiler_session.handle_start_command(cmd) }
+          @handlers['stop_profiler']  = Proc.new { |cmd| thread_profiler_session.handle_stop_command(cmd) }
+          @handlers['active_xray_sessions'] = Proc.new { |cmd| xray_session_collection.handle_active_xray_sessions(cmd) }
         end
 
         def new_relic_service
           NewRelic::Agent.instance.service
         end
 
-        def handle_agent_commands
-          results = invoke_commands(get_agent_commands)
+        def check_for_and_handle_agent_commands
+          commands = get_agent_commands
+
+          stop_xray_sessions unless active_xray_command?(commands)
+
+          results = invoke_commands(commands)
           new_relic_service.agent_command_results(results) unless results.empty?
         end
 
+        def stop_xray_sessions
+          self.xray_session_collection.stop_all_sessions
+        end
+
+        def active_xray_command?(commands)
+          commands.any? {|command| command.name == 'active_xray_sessions'}
+        end
+
+        NO_PROFILES_TO_SEND = {}.freeze
+
+        def harvest_data_to_send(disconnecting)
+          profiles = []
+          profiles += harvest_from_xray_session_collection
+          profiles += harvest_from_thread_profiler_session(disconnecting)
+
+          format_harvest_data(profiles)
+        end
+
+        def harvest_from_xray_session_collection
+          self.xray_session_collection.harvest_thread_profiles
+        end
+
+        def harvest_from_thread_profiler_session(disconnecting)
+          if self.thread_profiler_session.ready_to_harvest?(disconnecting)
+            self.thread_profiler_session.stop(true)
+            [self.thread_profiler_session.harvest]
+          else
+            []
+          end
+        end
+
+        def format_harvest_data(profiles)
+          if profiles.empty?
+            NewRelic::Agent.logger.debug "No thread profiles with data found to send."
+            NO_PROFILES_TO_SEND
+          else
+            log_profiles(profiles)
+            {:profile_data => profiles}
+          end
+        end
+
+        def log_profiles(profiles)
+          profile_descriptions = profiles.map { |p| p.to_log_description }
+          ::NewRelic::Agent.logger.debug "Sending thread profiles [#{profile_descriptions.join(", ")}]"
+        end
+
         def get_agent_commands
           commands = new_relic_service.get_agent_commands
           NewRelic::Agent.logger.debug "Received get_agent_commands = #{commands.inspect}"
-          commands
+          commands.map {|collector_command| AgentCommand.new(collector_command)}
         end
 
-        def invoke_commands(collector_commands)
+        def invoke_commands(agent_commands)
           results = {}
 
-          collector_commands.each do |collector_command|
-            agent_command = NewRelic::Agent::Commands::AgentCommand.new(collector_command)
+          agent_commands.each do |agent_command|
             results[agent_command.id.to_s] = invoke_command(agent_command)
           end
 
@@ -56,6 +117,7 @@ module NewRelic
             call_handler_for(agent_command)
             return success
           rescue AgentCommandError => e
+            NewRelic::Agent.logger.debug(e)
             error(e)
           end
         end
@@ -68,7 +130,7 @@ module NewRelic
         end
 
         def error(err)
-          { ERROR_KEY => err.message}
+          { ERROR_KEY => err.message }
         end
 
         def call_handler_for(agent_command)