newrelic_rpm 3.6.6.147 → 3.6.7.152

data/install.rb

@@ -4,10 +4,10 @@
 
 if __FILE__ == $0 || $0 =~ /script\/plugin/
   $LOAD_PATH << File.expand_path(File.join(File.dirname(__FILE__), 'lib'))
-  require 'new_relic/command'
+  require 'new_relic/cli/command'
   begin
-    NewRelic::Command::Install.new(:quiet => true, :app_name => 'My Application').run
-  rescue NewRelic::Command::CommandFailure => e
+    NewRelic::Cli::Install.new(:quiet => true, :app_name => 'My Application').run
+  rescue NewRelic::Cli::CommandFailure => e
     $stderr.puts e.message
   end
 end

data/lib/new_relic/agent.rb

@@ -89,13 +89,12 @@ module NewRelic
     require 'new_relic/agent/stats_engine'
     require 'new_relic/agent/transaction_sampler'
     require 'new_relic/agent/sql_sampler'
-    require 'new_relic/agent/thread_profiler'
+    require 'new_relic/agent/commands/thread_profiler'
     require 'new_relic/agent/error_collector'
     require 'new_relic/agent/busy_calculator'
     require 'new_relic/agent/sampler'
     require 'new_relic/agent/database'
     require 'new_relic/agent/pipe_channel_manager'
-    require 'new_relic/agent/transaction_info'
     require 'new_relic/agent/configuration'
     require 'new_relic/agent/rules_engine'
     require 'new_relic/agent/http_clients/uri_util'
@@ -384,20 +383,19 @@ module NewRelic
 
     # Check to see if we are capturing metrics currently on this thread.
     def is_execution_traced?
-      untraced = Thread.current[:newrelic_untraced]
-      untraced.nil? || untraced.last != false
+      NewRelic::Agent::TransactionState.get.is_traced?
     end
 
     # helper method to check the thread local to determine whether the
     # transaction in progress is traced or not
     def is_transaction_traced?
-      Thread::current[:record_tt] != false
+      NewRelic::Agent::TransactionState.get.is_transaction_traced?
     end
 
     # helper method to check the thread local to determine whether sql
     # is being recorded or not
     def is_sql_recorded?
-      Thread::current[:record_sql] != false
+      NewRelic::Agent::TransactionState.get.is_sql_recorded?
     end
 
     # Set a filter to be applied to errors that the Ruby Agent will

data/lib/new_relic/agent/agent.rb

@@ -8,12 +8,14 @@ require 'net/http'
 require 'logger'
 require 'zlib'
 require 'stringio'
+require 'new_relic/agent/sampled_buffer'
 require 'new_relic/agent/autostart'
 require 'new_relic/agent/new_relic_service'
 require 'new_relic/agent/pipe_service'
 require 'new_relic/agent/configuration/manager'
 require 'new_relic/agent/database'
-require 'new_relic/agent/thread_profiler'
+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'
@@ -31,13 +33,20 @@ module NewRelic
       extend NewRelic::Agent::Configuration::Instance
 
       def initialize
+        # FIXME: temporary work around for RUBY-839
+        # This should be handled with a configuration callback
+        if Agent.config[:monitor_mode]
+          @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
         @sql_sampler           = NewRelic::Agent::SqlSampler.new
-        @thread_profiler       = NewRelic::Agent::ThreadProfiler.new
+        @thread_profiler       = NewRelic::Agent::Commands::ThreadProfiler.new
+        @agent_command_router  = NewRelic::Agent::Commands::AgentCommandRouter.new(@service, @thread_profiler)
         @cross_app_monitor     = NewRelic::Agent::CrossAppMonitor.new(@events)
         @error_collector       = NewRelic::Agent::ErrorCollector.new
         @transaction_rules     = NewRelic::Agent::RulesEngine.new
@@ -51,12 +60,6 @@ module NewRelic
 
         @last_harvest_time = Time.now
         @obfuscator = lambda {|sql| NewRelic::Agent::Database.default_sql_obfuscator(sql) }
-
-        # FIXME: temporary work around for RUBY-839
-        # This should be handled with a configuration callback
-        if Agent.config[:monitor_mode]
-          @service = NewRelic::Agent::NewRelicService.new
-        end
       end
 
       # contains all the class-level methods for NewRelic::Agent::Agent
@@ -81,6 +84,7 @@ module NewRelic
         attr_reader :sql_sampler
         # begins a thread profile session when instructed by agent commands
         attr_reader :thread_profiler
+        attr_reader :agent_command_router
         # error collector is a simple collection of recorded errors
         attr_reader :error_collector
         attr_reader :harvest_samplers
@@ -266,8 +270,8 @@ module NewRelic
         # should not record sql in the current thread. Returns the
         # previous value, if there is one
         def set_record_sql(should_record)
-          prev = Thread::current[:record_sql]
-          Thread::current[:record_sql] = should_record
+          prev = TransactionState.get.record_sql
+          TransactionState.get.record_sql = should_record
           prev.nil? || prev
         end
 
@@ -275,8 +279,8 @@ module NewRelic
         # should not record transaction traces in the current
         # thread. Returns the previous value, if there is one
         def set_record_tt(should_record)
-          prev = Thread::current[:record_tt]
-          Thread::current[:record_tt] = should_record
+          prev = TransactionState.get.record_tt
+          TransactionState.get.record_tt = should_record
           prev.nil? || prev
         end
 
@@ -285,18 +289,13 @@ module NewRelic
         # children of a transaction without affecting the tracing of
         # the whole transaction
         def push_trace_execution_flag(should_trace=false)
-          value = Thread.current[:newrelic_untraced]
-          if (value.nil?)
-            Thread.current[:newrelic_untraced] = []
-          end
-
-          Thread.current[:newrelic_untraced] << should_trace
+          TransactionState.get.push_traced(should_trace)
         end
 
         # Pop the current trace execution status.  Restore trace execution status
         # to what it was before we pushed the current flag.
         def pop_trace_execution_flag
-          Thread.current[:newrelic_untraced].pop if Thread.current[:newrelic_untraced]
+          TransactionState.get.pop_traced
         end
 
         # Herein lies the corpse of the former 'start' method. May
@@ -335,8 +334,12 @@ module NewRelic
           # assist with proper dispatcher detection
           def log_dispatcher
             dispatcher_name = Agent.config[:dispatcher].to_s
-            return if log_if(dispatcher_name.empty?, :info, "No known dispatcher detected.")
-            ::NewRelic::Agent.logger.info "Dispatcher: #{dispatcher_name}"
+
+            if dispatcher_name.empty?
+              ::NewRelic::Agent.logger.info 'No known dispatcher detected.'
+            else
+              ::NewRelic::Agent.logger.info "Dispatcher: #{dispatcher_name}"
+            end
           end
 
           def log_app_name
@@ -400,35 +403,27 @@ module NewRelic
             ::NewRelic::Agent.logger.debug "New Relic Ruby Agent #{NewRelic::VERSION::STRING} Initialized: pid = #{$$}"
           end
 
-          # A helper method that logs a condition if that condition is
-          # true. Mentally cleaner than having every method set a
-          # local and log if it is true
-          def log_if(boolean, level, message)
-            ::NewRelic::Agent.logger.send(level, message) if boolean
-            boolean
-          end
-
-          # A helper method that logs a condition unless that
-          # condition is true. Mentally cleaner than having every
-          # method set a local and log unless it is true
-          def log_unless(boolean, level, message)
-            ::NewRelic::Agent.logger.send(level, message) unless boolean
-            boolean
-          end
-
           # Warn the user if they have configured their agent not to
           # send data, that way we can see this clearly in the log file
           def monitoring?
-            log_unless(Agent.config[:monitor_mode], :warn,
-                       "Agent configured not to send data in this environment.")
+            if Agent.config[:monitor_mode]
+              true
+            else
+              ::NewRelic::Agent.logger.warn('Agent configured not to send data in this environment.')
+              false
+            end
           end
 
           # Tell the user when the license key is missing so they can
           # fix it by adding it to the file
           def has_license_key?
-            log_unless(Agent.config[:license_key], :warn,
-                       "No license key found in newrelic.yml config. " +
-                       "This often means your newrelic.yml is missing a section for the running environment '#{NewRelic::Control.instance.env}'")
+            if Agent.config[:license_key] && Agent.config[:license_key].length > 0
+              true
+            else
+              ::NewRelic::Agent.logger.warn("No license key found in newrelic.yml config. " +
+                "This often means your newrelic.yml is missing a section for the running environment '#{NewRelic::Control.instance.env}'")
+              false
+            end
           end
 
           # A correct license key exists and is of the proper length
@@ -440,15 +435,25 @@ module NewRelic
           # usually looks something like a SHA1 hash
           def correct_license_length
             key = Agent.config[:license_key]
-            log_unless((key.length == 40), :error, "Invalid license key: #{key}")
+
+            if key.length == 40
+              true
+            else
+              ::NewRelic::Agent.logger.error("Invalid license key: #{key}")
+              false
+            end
           end
 
           # If we're using a dispatcher that forks before serving
           # requests, we need to wait until the children are forked
           # before connecting, otherwise the parent process sends odd data
           def using_forking_dispatcher?
-            log_if([:passenger, :rainbows, :unicorn].include?(Agent.config[:dispatcher]),
-                   :info, "Connecting workers after forking.")
+            if [:passenger, :rainbows, :unicorn].include? Agent.config[:dispatcher]
+              ::NewRelic::Agent.logger.info 'Connecting workers after forking.'
+              true
+            else
+              false
+            end
           end
 
           # Return true if we're using resque and it hasn't had a chance to (potentially)
@@ -651,7 +656,7 @@ module NewRelic
           end
 
           ::NewRelic::Agent.logger.debug "Creating Ruby Agent worker thread."
-          @worker_thread = NewRelic::Agent::AgentThread.new('Worker Loop') do
+          @worker_thread = NewRelic::Agent::Threading::AgentThread.new('Worker Loop') do
             deferred_work!(connection_options)
           end
         end
@@ -977,21 +982,10 @@ module NewRelic
         # unnecessary overhead of running explains on fast queries.)
         def harvest_and_send_slowest_sample
           harvest_transaction_traces
-          unless @traces.empty?
-            now = Time.now
-            ::NewRelic::Agent.logger.debug "Sending (#{@traces.length}) transaction traces"
 
+          unless @traces.empty?
             begin
-              options = { :keep_backtraces => true }
-              if !(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 = @traces.map {|trace| trace.prepare_to_send(options) }
-              @service.transaction_sample_data(traces)
-              ::NewRelic::Agent.logger.debug "Sent slowest sample (#{@service.agent_id}) in #{Time.now - now} seconds"
+              send_slowest_sample
             rescue UnrecoverableServerException => e
               ::NewRelic::Agent.logger.debug e.message
             end
@@ -1003,6 +997,25 @@ module NewRelic
           @traces = nil
         end
 
+        def send_slowest_sample
+          start_time = Time.now
+          ::NewRelic::Agent.logger.debug "Sending (#{@traces.length}) transaction traces"
+
+          options = { :keep_backtraces => true }
+          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 = @traces.map {|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"
+        end
+
         def harvest_and_send_thread_profile(disconnecting=false)
           @thread_profiler.stop(true) if disconnecting
 
@@ -1048,19 +1061,10 @@ module NewRelic
           samples = @request_sampler.samples
           @service.analytic_event_data(samples) unless samples.empty?
           @request_sampler.reset
-        rescue => e
-          NewRelic::Agent.logger.debug "Failed to sent analytics; throttling to conserve memory"
-          @request_sampler.throttle
-          raise
         end
 
-        def check_for_agent_commands
-          commands = @service.get_agent_commands
-          ::NewRelic::Agent.logger.debug "Received get_agent_commands = #{commands.inspect}"
-
-          @thread_profiler.respond_to_commands(commands) do |command_id, error|
-            @service.agent_command_results(command_id, error)
-          end
+        def handle_agent_commands
+          @agent_command_router.handle_agent_commands
         end
 
         def transmit_data(disconnecting=false)
@@ -1074,9 +1078,9 @@ module NewRelic
             harvest_and_send_slowest_sql
             harvest_and_send_timeslice_data
             harvest_and_send_analytic_event_data
-            harvest_and_send_thread_profile(disconnecting)
 
-            check_for_agent_commands
+            handle_agent_commands
+            harvest_and_send_thread_profile(disconnecting)
           end
         rescue EOFError => e
           ::NewRelic::Agent.logger.warn("EOFError after #{Time.now - now}s when transmitting data to New Relic Service.")

data/lib/new_relic/agent/autostart.rb

@@ -24,10 +24,8 @@ module NewRelic
       # 'autostart.blacklisted_executables' and
       # 'autostart.blacklisted_rake_tasks'
       def agent_should_start?
-          !::NewRelic::Agent.config['autostart.blacklisted_constants'] \
-            .split(/\s*,\s*/).any?{ |name| constant_is_defined?(name) } &&
-          !::NewRelic::Agent.config['autostart.blacklisted_executables'] \
-            .split(/\s*,\s*/).any?{ |bin| File.basename($0) == bin } &&
+          !blacklisted?('autostart.blacklisted_constants') { |name| constant_is_defined?(name) } &&
+          !blacklisted?('autostart.blacklisted_executables') { |bin| File.basename($0) == bin } &&
           !in_blacklisted_rake_task?
       end
 
@@ -36,13 +34,28 @@ module NewRelic
       def constant_is_defined?(const_name)
         const_name.to_s.sub(/\A::/,'').split('::').inject(Object) do |namespace, name|
           begin
-            namespace.const_get(name)
+            result = namespace.const_get(name)
+
+            # const_get looks up the inheritence chain, so if it's a class
+            # in the constant make sure we found the one in our namespace.
+            #
+            # Can't help if the constant isn't a class...
+            if result.is_a?(Module)
+              expected_name = "#{namespace}::#{name}".gsub(/^Object::/, "")
+              return false unless expected_name == result.to_s
+            end
+
+            result
           rescue NameError
             false
           end
         end
       end
 
+      def blacklisted?(key, &block)
+        ::NewRelic::Agent.config[key].split(/\s*,\s*/).any?(&block)
+      end
+
       def in_blacklisted_rake_task?
         tasks = begin
             ::Rake.application.top_level_tasks

data/lib/new_relic/agent/browser_monitoring.rb

@@ -4,12 +4,17 @@
 
 require 'base64'
 require 'new_relic/agent/beacon_configuration'
+require 'new_relic/agent/transaction_timings'
+
 module NewRelic
   module Agent
     # This module contains support for Real User Monitoring - the
     # javascript generation and configuration
     module BrowserMonitoring
       class DummyTransaction
+
+        attr_accessor :start_time
+
         def initialize
           @attributes = {}
         end
@@ -22,6 +27,10 @@ module NewRelic
           0.0
         end
 
+        def timings
+          NewRelic::Agent::TransactionTimings.new(0.0, NewRelic::Agent::TransactionState.get)
+        end
+
         def name
           ::NewRelic::Agent::UNKNOWN_METRIC
         end
@@ -39,11 +48,7 @@ module NewRelic
       # page as is reasonably possible - that is, before any style or
       # javascript inclusions, but after any header-related meta tags
       def browser_timing_header
-        if insert_js?
-          NewRelic::Agent.instance.beacon_configuration.browser_timing_header
-        else
-          ""
-        end
+        insert_js? ? header_js_string : ""
       end
 
       # This method returns a string suitable for inclusion in a page
@@ -67,6 +72,9 @@ module NewRelic
 
       def obfuscate(config, text)
         obfuscated = ""
+        if defined?(::Encoding::ASCII_8BIT)
+          obfuscated.force_encoding(::Encoding::ASCII_8BIT)
+        end
         key_bytes = config.license_bytes
         index = 0
         text.each_byte{|byte|
@@ -78,34 +86,15 @@ module NewRelic
       end
 
       def browser_monitoring_transaction_name
-        current_transaction.name || ::NewRelic::Agent::UNKNOWN_METRIC
-      end
-
-      def browser_monitoring_queue_time
-        clamp_to_positive((current_transaction.queue_time.to_f * 1000.0).round)
-      end
-
-      def browser_monitoring_app_time
-        clamp_to_positive(((Time.now - browser_monitoring_start_time).to_f * 1000.0).round)
+        current_timings.transaction_name || ::NewRelic::Agent::UNKNOWN_METRIC
       end
 
       def current_transaction
-        NewRelic::Agent::TransactionInfo.get.transaction || @@dummy_txn
+        NewRelic::Agent::TransactionState.get.transaction || @@dummy_txn
       end
 
-      def clamp_to_positive(value)
-        return 0.0 if value < 0
-        value
-      end
-
-      def browser_monitoring_start_time
-        NewRelic::Agent::TransactionInfo.get.start_time
-      end
-
-      def self.timings
-        NewRelic::Agent::Instrumentation::BrowserMonitoringTimings.new(
-          current_transaction.queue_time,
-          NewRelic::Agent::TransactionInfo.get)
+      def current_timings
+        NewRelic::Agent::TransactionState.get.timings
       end
 
       def insert_mobile_response_header(request, response)
@@ -116,7 +105,7 @@ module NewRelic
 
           response['X-NewRelic-Beacon-Url'] = beacon_url(request)
 
-          payload = %[ ["#{Agent.config[:application_id]}","#{obfuscate(config, browser_monitoring_transaction_name)}",#{browser_monitoring_queue_time},#{browser_monitoring_app_time}] ]
+          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
@@ -152,7 +141,7 @@ module NewRelic
         elsif ! NewRelic::Agent.is_execution_traced?
           ::NewRelic::Agent.logger.debug "Execution is not traced. Skipping browser instrumentation."
           false
-        elsif NewRelic::Agent::TransactionInfo.get.ignore_end_user?
+        elsif NewRelic::Agent::TransactionState.get.request_ignore_enduser
           ::NewRelic::Agent.logger.debug "Ignore end user for this transaction is set. Skipping browser instrumentation."
           false
         else
@@ -161,7 +150,7 @@ module NewRelic
       end
 
       def generate_footer_js(config)
-        if browser_monitoring_start_time
+        if current_transaction.start_time
           footer_js_string(config)
         else
           ''
@@ -173,15 +162,28 @@ module NewRelic
       end
 
       def tt_guid
-        transaction = NewRelic::Agent::TransactionInfo.get
-        return transaction.guid if transaction.include_guid?
+        state = NewRelic::Agent::TransactionState.get
+        return state.request_guid if include_guid?(state)
         ""
       end
 
+      def include_guid?(state)
+        state.request_token &&
+          state.timings.app_time_in_seconds > state.transaction.apdex_t
+      end
+
       def tt_token
-        return NewRelic::Agent::TransactionInfo.get.token
+        return NewRelic::Agent::TransactionState.get.request_token
+      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
       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)
 
@@ -189,7 +191,11 @@ module NewRelic
         account = obfuscate(config, transaction_attribute(:account))
         product = obfuscate(config, transaction_attribute(:product))
 
-        html_safe_if_needed(%'<script type="text/javascript">#{config.browser_timing_static_footer}NREUMQ.push(["#{config.finish_command}","#{Agent.config[:beacon]}","#{Agent.config[:browser_key]}","#{Agent.config[:application_id]}","#{obfuscated_transaction_name}",#{browser_monitoring_queue_time},#{browser_monitoring_app_time},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
 
       def html_safe_if_needed(string)