newrelic_rpm 3.6.7.159 → 3.6.8.164

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

@@ -0,0 +1,110 @@
+# encoding: utf-8
+# 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/agent/threading/agent_thread'
+require 'new_relic/agent/threading/backtrace_service'
+require 'new_relic/agent/threading/thread_profile'
+
+module NewRelic
+  module Agent
+    module Commands
+
+      class ThreadProfilerSession
+
+        def initialize(backtrace_service)
+          @backtrace_service = backtrace_service
+        end
+
+        def handle_start_command(agent_command)
+          raise_unsupported_error unless NewRelic::Agent::Threading::BacktraceService.is_supported?
+          raise_thread_profiler_disabled unless enabled?
+          raise_already_started_error if running?
+          start(agent_command)
+        end
+
+        def handle_stop_command(agent_command)
+          report_data = agent_command.arguments.fetch("report_data", true)
+          stop(report_data)
+        end
+
+        def start(agent_command)
+          NewRelic::Agent.logger.debug("Starting Thread Profiler.")
+          profile = @backtrace_service.subscribe(
+            NewRelic::Agent::Threading::BacktraceService::ALL_TRANSACTIONS,
+            agent_command.arguments
+          )
+
+          @started_at = Time.now
+          @duration = profile.duration if profile
+        end
+
+        def stop(report_data)
+          return unless running?
+          NewRelic::Agent.logger.debug("Stopping Thread Profiler.")
+          @finished_profile = @backtrace_service.harvest(NewRelic::Agent::Threading::BacktraceService::ALL_TRANSACTIONS)
+          @backtrace_service.unsubscribe(NewRelic::Agent::Threading::BacktraceService::ALL_TRANSACTIONS)
+          @finished_profile = nil if !report_data
+        end
+
+        def harvest
+          NewRelic::Agent.logger.debug("Harvesting from Thread Profiler #{@finished_profile.to_log_description unless @finished_profile.nil?}")
+          profile = @finished_profile
+          @backtrace_service.profile_agent_code = false
+          @finished_profile = nil
+          @started_at = nil
+          profile
+        end
+
+        def enabled?
+          NewRelic::Agent.config[:'thread_profiler.enabled']
+        end
+
+        def running?
+          @backtrace_service.subscribed?(NewRelic::Agent::Threading::BacktraceService::ALL_TRANSACTIONS)
+        end
+
+        def ready_to_harvest?(disconnecting=false)
+          (running? && disconnecting) || past_time? || stopped?
+        end
+
+        def past_time?
+          @started_at && (Time.now > @started_at + @duration)
+        end
+
+        def stopped?
+          !!@finished_profile
+        end
+
+        private
+
+        def raise_command_error(msg)
+          raise NewRelic::Agent::Commands::AgentCommandRouter::AgentCommandError.new(msg)
+        end
+
+        def raise_unsupported_error
+          msg = <<-EOF
+Thread profiling is only supported on 1.9.2 and greater versions of Ruby.
+We detected running agents capable of profiling, but the profile started with
+an agent running Ruby #{RUBY_VERSION}.
+
+Profiling again might select an appropriate agent, but we recommend running a
+consistent version of Ruby across your application for better results.
+          EOF
+          raise_command_error(msg)
+        end
+
+        def raise_thread_profiler_disabled
+          msg = "Not starting Thread Profiler because of config 'thread_profiler.enabled' = #{enabled?}"
+          raise_command_error(msg)
+        end
+
+        def raise_already_started_error
+          msg = "Profile already in progress. Ignoring agent command to start another."
+          raise_command_error(msg)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require 'forwardable'
+
+module NewRelic
+  module Agent
+    module Commands
+      class XraySession
+        extend Forwardable
+
+        attr_reader :id, :command_arguments
+        attr_reader :xray_session_name, :key_transaction_name,
+                    :requested_trace_count, :duration, :sample_period
+
+        def initialize(command_arguments)
+          @command_arguments     = command_arguments
+          @id                    = command_arguments.fetch("x_ray_id", nil)
+          @xray_session_name     = command_arguments.fetch("xray_session_name", "")
+          @key_transaction_name  = command_arguments.fetch("key_transaction_name", "")
+          @requested_trace_count = command_arguments.fetch("requested_trace_count", 100)
+          @duration              = command_arguments.fetch("duration", 86400)
+          @sample_period         = command_arguments.fetch("sample_period", 0.1)
+          @run_profiler          = command_arguments.fetch("run_profiler", true)
+        end
+
+        def active?
+          @active
+        end
+
+        def run_profiler?
+          @run_profiler && NewRelic::Agent.config[:'xray_session.allow_profiles']
+        end
+
+        def activate
+          @active = true
+          @start_time = Time.now
+        end
+
+        def deactivate
+          @active = false
+        end
+
+        def requested_period
+          @sample_period
+        end
+
+        def finished?
+          @start_time + @duration < Time.now
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,158 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+require 'forwardable'
+require 'thread'
+require 'new_relic/agent/commands/xray_session'
+
+module NewRelic
+  module Agent
+    module Commands
+      class XraySessionCollection
+        extend Forwardable
+
+        def initialize(backtrace_service, event_listener)
+          @backtrace_service = backtrace_service
+
+          # This lock protects access to the sessions hash, but it's expected
+          # that individual session objects within the hash will be manipulated
+          # outside the lock.  This is safe because manipulation of the session
+          # objects is expected from only a single thread (the harvest thread)
+          @sessions_lock = Mutex.new
+          @sessions = {}
+
+          if event_listener
+            event_listener.subscribe(:before_harvest, &method(:cleanup_finished_sessions))
+          end
+        end
+
+        def handle_active_xray_sessions(agent_command)
+          # If X-Rays are disabled, just be quiet about it and don't start the
+          # command. Other hosts might be running the X-Ray, so we don't need
+          # to bark on every get_agent_commands.
+          if !NewRelic::Agent.config[:'xray_session.enabled']
+            NewRelic::Agent.logger.debug("Not responding to X-Ray command because of config 'xray_session.enabled' = #{NewRelic::Agent.config[:'xray_session.enabled']}")
+            return
+          end
+
+          incoming_ids = agent_command.arguments["xray_ids"]
+          deactivate_for_incoming_sessions(incoming_ids)
+          activate_sessions(incoming_ids)
+        end
+
+        def session_id_for_transaction_name(name)
+          @sessions_lock.synchronize do
+            @sessions.keys.find { |id| @sessions[id].key_transaction_name == name }
+          end
+        end
+
+        NO_PROFILES = [].freeze
+
+        def harvest_thread_profiles
+          return NO_PROFILES unless NewRelic::Agent::Threading::BacktraceService.is_supported?
+
+          profiles = active_thread_profiling_sessions.map do |session|
+            NewRelic::Agent.logger.debug("Harvesting profile for X-Ray session #{session.inspect}")
+            @backtrace_service.harvest(session.key_transaction_name)
+          end
+          profiles.reject! {|p| p.empty?}
+          profiles.compact
+        end
+
+        def stop_all_sessions
+          deactivate_for_incoming_sessions([])
+        end
+
+        def cleanup_finished_sessions
+          finished_session_ids.each do |id|
+            NewRelic::Agent.logger.debug("Finished X-Ray session #{id} by duration. Removing it from active sessions.")
+            remove_session_by_id(id)
+          end
+        end
+
+
+        ### Internals
+
+        def new_relic_service
+          NewRelic::Agent.instance.service
+        end
+
+        # These are unsynchonized and should only be used for testing
+        def_delegators :@sessions, :[], :include?
+
+        def active_thread_profiling_sessions
+          @sessions_lock.synchronize do
+            @sessions.values.select { |s| s.active? && s.run_profiler? }
+          end
+        end
+
+        ### Session activation
+
+        def activate_sessions(incoming_ids)
+          lookup_metadata_for(ids_to_activate(incoming_ids)).each do |raw|
+            add_session(XraySession.new(raw))
+          end
+        end
+
+        def ids_to_activate(incoming_ids)
+          @sessions_lock.synchronize { incoming_ids - @sessions.keys }
+        end
+
+        # Please don't hold the @sessions_lock across me! Calling the service
+        # is time-consuming, and will block request threads. Which is rude.
+        def lookup_metadata_for(ids_to_activate)
+          return [] if ids_to_activate.empty?
+
+          NewRelic::Agent.logger.debug("Retrieving metadata for X-Ray sessions #{ids_to_activate.inspect}")
+          new_relic_service.get_xray_metadata(ids_to_activate)
+        end
+
+        def add_session(session)
+          NewRelic::Agent.logger.debug("Adding X-Ray session #{session.inspect}")
+          NewRelic::Agent.increment_metric("Supportability/XraySessions/Starts")
+
+          @sessions_lock.synchronize { @sessions[session.id] = session }
+
+          session.activate
+          if session.run_profiler?
+            @backtrace_service.subscribe(session.key_transaction_name, session.command_arguments)
+          end
+        end
+
+        ### Session deactivation
+
+        def deactivate_for_incoming_sessions(incoming_ids)
+          ids_to_remove(incoming_ids).each do |session_id|
+            remove_session_by_id(session_id)
+          end
+        end
+
+        def ids_to_remove(incoming_ids)
+          @sessions_lock.synchronize { @sessions.keys - incoming_ids }
+        end
+
+        def remove_session_by_id(id)
+          session = @sessions_lock.synchronize { @sessions.delete(id) }
+
+          if session
+            NewRelic::Agent.logger.debug("Removing X-Ray session #{session.inspect}")
+            NewRelic::Agent.increment_metric("Supportability/XraySessions/Stops")
+
+            if session.run_profiler?
+              @backtrace_service.unsubscribe(session.key_transaction_name)
+            end
+            session.deactivate
+          end
+        end
+
+        def finished_session_ids
+          @sessions_lock.synchronize do
+            @sessions.map{|k, s| k if s.finished?}.compact
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/new_relic/agent/configuration/default_source.rb

@@ -91,7 +91,7 @@ module NewRelic
         end
 
         def self.thread_profiler_enabled
-          Proc.new { NewRelic::Agent::Commands::ThreadProfiler.is_supported? }
+          Proc.new { NewRelic::Agent::Threading::BacktraceService.is_supported? }
         end
 
         def self.browser_monitoring_auto_instrument
@@ -153,6 +153,7 @@ module NewRelic
         'assets:clobber',
         'assets:environment',
         'assets:precompile',
+        'assets:precompile:all',
         'db:create',
         'db:drop',
         'db:fixtures:load',
@@ -245,7 +246,7 @@ module NewRelic
         },
         :monitor_mode => {
           :default => DefaultSource.monitor_mode,
-          :public => false,
+          :public => true,
           :type => Boolean,
           :description => 'Enable or disable transmission of data to the New Relic data collection service.'
         },
@@ -513,12 +514,6 @@ module NewRelic
           :type => Boolean,
           :description => 'Enable or disable memcache instrumentation.'
         },
-        :disable_mobile_headers => {
-          :default => true,
-          :public => false,
-          :type => Boolean,
-          :description => 'Enable or disable injection of mobile response headers when mobile headers are present in the incoming request.'
-        },
         :capture_params => {
           :default => false,
           :public => true,
@@ -579,18 +574,6 @@ module NewRelic
           :type => Fixnum,
           :description => 'Maximum number of transaction trace segments to record in a single transaction trace.'
         },
-        :'transaction_tracer.random_sample' => {
-          :default => false,
-          :public => false,
-          :type => Boolean,
-          :description => 'Enable or disable the collection of a random transaction trace during each harvest cycle in addition to the longest transaction trace.'
-        },
-        :sample_rate => {
-          :default => 10,
-          :public => false,
-          :type => Fixnum,
-          :description => 'Number of harvests between random transaction trace samples in the transaction sampler.'
-        },
         :'slow_sql.enabled' => {
           :default => DefaultSource.slow_sql_enabled,
           :public => true,
@@ -663,6 +646,24 @@ module NewRelic
           :type => Boolean,
           :description => 'Enable or disable automatic insertion of the real user monitoring header and footer into outgoing responses.'
         },
+        :'js_agent_loader_version' => {
+          :default => '',
+          :public => false,
+          :type => String,
+          :description => 'Version of the JavaScript agent loader retrieved by the collector. This is only informational, setting the value does nothing.'
+        },
+        :'js_agent_loader' => {
+          :default => '',
+          :public => false,
+          :type => String,
+          :description => 'JavaScript agent loader content.'
+        },
+        :'js_errors_beta' => {
+          :default => false,
+          :public => false,
+          :type => Boolean,
+          :description => 'Enable or disable beta JavaScript error reporting.'
+        },
         :trusted_account_ids => {
           :default => [],
           :public => false,
@@ -681,23 +682,59 @@ module NewRelic
           :type => Boolean,
           :description => 'Enable or disable the thread profiler.'
         },
+        :'xray_session.enabled' => {
+          :default => true,
+          :public => true,
+          :type => Boolean,
+          :description => 'Enable or disable X-Ray sessions.'
+        },
+        :'xray_session.allow_traces' => {
+          :default => true,
+          :public => false,
+          :type => Boolean,
+          :description => 'Enable or disable X-Ray sessions recording transaction traces.'
+        },
+        :'xray_session.allow_profiles' => {
+          :default => true,
+          :public => false,
+          :type => Boolean,
+          :description => 'Enable or disable X-Ray sessions taking thread profiles.'
+        },
+        :'xray_session.max_samples' => {
+          :default => 10,
+          :public => false,
+          :type => Fixnum,
+          :description => 'Maximum number of transaction traces to buffer for active X-Ray sessions'
+        },
+        :'xray_session.max_profile_overhead' => {
+          :default => 0.05,
+          :public => false,
+          :type => Float,
+          :description => 'Maximum overhead percentage for thread profiling before agent reduces polling frequency'
+        },
         :marshaller => {
           :default => DefaultSource.marshaller,
           :public => true,
           :type => String,
           :description => 'Marshaller to use when marshalling data for transmission to the New Relic data collection service (e.g json, pruby).'
         },
-        :'request_sampler.enabled' => {
+        :'analytics_events.enabled' => {
+          :default => true,
+          :public => true,
+          :type => Boolean,
+          :description => 'Enable or disable the analytics event sampling.'
+        },
+        :'analytics_events.transactions.enabled' => {
           :default => true,
           :public => true,
           :type => Boolean,
-          :description => 'Enable or disable the request sampler.'
+          :description => 'Enable or disable the analytics event sampling for transactions.'
         },
-        :'request_sampler.max_samples' => {
+        :'analytics_events.max_samples_stored' => {
           :default => 1200,
           :public => false,
           :type => Fixnum,
-          :description => 'Maximum number of request events recorded by the request sampler in a single harvest.'
+          :description => 'Maximum number of request events recorded by the analytics event sampling in a single harvest.'
         },
       }.freeze