newrelic_rpm 3.8.1.221 → 3.9.0.229

data/lib/new_relic/agent/agent_logger.rb

@@ -3,6 +3,7 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require 'logger'
+require 'new_relic/agent/hostname'
 
 module NewRelic
   module Agent
@@ -44,7 +45,7 @@ module NewRelic
       end
 
       def is_startup_logger?
-        false
+        @log.is_a?(NullLogger)
       end
 
       # Use this when you want to log an exception with explicit control over
@@ -161,7 +162,7 @@ module NewRelic
       end
 
       def set_log_format!
-        @hostname = Socket.gethostname
+        @hostname = NewRelic::Agent::Hostname.get
         @prefix = wants_stdout? ? '** [NewRelic]' : ''
         @log.formatter = Proc.new do |severity, timestamp, progname, msg|
           "#{@prefix}[#{timestamp.strftime("%m/%d/%y %H:%M:%S %z")} #{@hostname} (#{$$})] #{severity} : #{msg}\n"

data/lib/new_relic/agent/audit_logger.rb

@@ -4,6 +4,7 @@
 
 require 'logger'
 require 'fileutils'
+require 'new_relic/agent/hostname'
 
 module NewRelic
   module Agent
@@ -66,7 +67,7 @@ module NewRelic
       end
 
       def create_log_formatter
-        @hostname = Socket.gethostname
+        @hostname = NewRelic::Agent::Hostname.get
         Proc.new do |severity, time, progname, msg|
           "[#{time} #{@hostname} (#{$$})] : #{msg}\n"
         end

data/lib/new_relic/agent/busy_calculator.rb

@@ -24,9 +24,10 @@ module NewRelic
       # sets up busy calculations based on the start and end of
       # transactions - used for a rough estimate of what percentage of
       # wall clock time is spent processing requests
-      def dispatcher_start(time)
-        TransactionState.get.busy_entries ||= 0
-        callers = TransactionState.get.busy_entries += 1
+      def dispatcher_start(time) #THREAD_LOCAL_ACCESS
+        state = TransactionState.tl_get
+        state.busy_entries ||= 0
+        callers = state.busy_entries += 1
         return if callers > 1
         @lock.synchronize do
           @entrypoint_stack.push time
@@ -36,12 +37,13 @@ module NewRelic
       # called when a transaction finishes, to add time to the
       # instance variable accumulator. this is harvested when we send
       # data to the server
-      def dispatcher_finish(end_time = nil)
+      def dispatcher_finish(end_time = nil) #THREAD_LOCAL_ACCESS
+        state = TransactionState.tl_get
         # If #dispatcher_start hasn't been called at least once, abort early
-        return unless TransactionState.get.busy_entries
+        return unless state.busy_entries
 
         end_time ||= time_now
-        callers = TransactionState.get.busy_entries -= 1
+        callers = state.busy_entries -= 1
 
         # Ignore nested calls
         return if callers > 0
@@ -63,9 +65,9 @@ module NewRelic
 
       # Reset the state of the information accumulated by all threads,
       # but only reset the recursion counter for this thread.
-      def reset
+      def reset #THREAD_LOCAL_ACCESS
         @entrypoint_stack = []
-        TransactionState.get.busy_entries = 0
+        TransactionState.tl_get.busy_entries = 0
         @lock ||= Mutex.new
         @accumulator = 0
         @harvest_start = time_now

data/lib/new_relic/agent/configuration.rb

@@ -28,19 +28,6 @@ require 'new_relic/agent/configuration/manager'
 module NewRelic
   module Agent
     module Configuration
-      # This can be mixed in with minimal impact to provide easy
-      # access to the config manager
-      module Instance
-        def config
-          @@manager ||= Manager.new
-        end
-
-        # for testing
-        def reset_config
-          @@manager = Manager.new
-        end
-      end
-
       class DottedHash < ::Hash
         def initialize(hash)
           self.merge!(dot_flattened(hash))

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

@@ -55,7 +55,7 @@ module NewRelic
             case
             when defined?(::NewRelic::TEST) then :test
             when defined?(::Merb) && defined?(::Merb::Plugins) then :merb
-            when defined?(::Rails)
+            when defined?(::Rails::VERSION)
               case Rails::VERSION::MAJOR
               when 0..2
                 :rails
@@ -313,12 +313,6 @@ module NewRelic
           :type => Boolean,
           :description => 'Determines if ruby-prof is available for developer mode profiling.'
         },
-        :'profiling.enabled' => {
-          :default => false,
-          :public => false,
-          :type => Boolean,
-          :description => 'Determines at runtime whether developer mode should be profiling or not.'
-        },
         :apdex_t => {
           :default => 0.5,
           :public => true,
@@ -576,6 +570,12 @@ module NewRelic
           :type => Boolean,
           :description => 'Enable or disable memcache instrumentation.'
         },
+        :disable_gc_profiler => {
+          :default => false,
+          :public => true,
+          :type => Boolean,
+          :description => 'Enable or disable usage of GC::Profiler to measure time spent in garbage collection'
+        },
         :capture_params => {
           :default => false,
           :public => true,
@@ -600,12 +600,6 @@ module NewRelic
           :type => Boolean,
           :description => 'Enable or disable capturing and attachment of memcache keys to transaction traces.'
         },
-        :textmate => {
-          :default => false,
-          :public => false,
-          :type => Boolean,
-          :description => 'Enables Textmate integration.'
-        },
         :'transaction_tracer.enabled' => {
           :default => true,
           :public => true,
@@ -714,12 +708,6 @@ module NewRelic
           :type => Boolean,
           :description => 'Enable or disable recording of traced errors and error count metrics.'
         },
-        :'error_collector.capture_source' => {
-          :default => true,
-          :public => true,
-          :type => Boolean,
-          :description => 'Enable or disable collection of source code for errors that support it.'
-        },
         :'error_collector.capture_attributes' => {
           :default => true,
           :public => true,
@@ -801,7 +789,7 @@ module NewRelic
         },
         :'browser_monitoring.capture_attributes' => {
           :default => false,
-          :public => false,
+          :public => true,
           :type => Boolean,
           :description => 'Include custom attributes in real user monitoring script in outgoing responses.'
         },
@@ -982,6 +970,13 @@ module NewRelic
           :dynamic_name => true,
           :description  => 'Controls whether instrumentation for the httpclient gem will be installed by the agent.'
         },
+        :disable_net_http => {
+          :default      => false,
+          :public       => true,
+          :type         => Boolean,
+          :dynamic_name => true,
+          :description  => 'Controls whether instrumentation for Net::HTTP will be installed by the agent.'
+        },
         :disable_mongo => {
           :default      => false,
           :public       => true,
@@ -1009,6 +1004,18 @@ module NewRelic
           :type         => Boolean,
           :dynamic_name => true,
           :description  => 'Controls whether instrumentation for the typhoeus gem will be installed by the agent.'
+        },
+        :disable_middleware_instrumentation => {
+          :default      => false,
+          :public       => true,
+          :type         => Boolean,
+          :description  => 'Controls whether 3rd-party middlewares will be wrapped in instrumentation (regardless of whether they are installed via Rack::Builder or Rails).'
+        },
+        :use_heroku_dyno_names => {
+          :default      => false,
+          :public       => false,
+          :type         => Boolean,
+          :description  => 'Controls whether or not we use the heroku dyno name as the hostname.'
         }
       }.freeze
 

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

@@ -13,9 +13,21 @@ module NewRelic
   module Agent
     module Configuration
       class Manager
-        extend Forwardable
-        def_delegators :@cache, :[], :has_key?, :keys
-        attr_reader :config_stack, :stripped_exceptions_whitelist
+        attr_reader :stripped_exceptions_whitelist
+
+        # Defining these explicitly saves object allocations that we incur
+        # if we use Forwardable and def_delegators.
+        def [](key)
+          @cache[key]
+        end
+
+        def has_key?(key)
+          @cache.has_key?[key]
+        end
+
+        def keys
+          @cache.keys
+        end
 
         def initialize
           reset_to_defaults
@@ -30,24 +42,35 @@ module NewRelic
           end
         end
 
-        def apply_config(source, level=0)
-          was_finished = finished_configuring?
-
+        def add_config_for_testing(source, level=0)
+          raise 'Invalid config type for testing' unless [Hash, DottedHash].include?(source.class)
           invoke_callbacks(:add, source)
-          @config_stack.insert(level, source.freeze)
+          @configs_for_testing << [source.freeze, level]
           reset_cache
           log_config(:add, source)
+        end
 
-          notify_finished_configuring if !was_finished && finished_configuring?
+        def remove_config_type(sym)
+          source = case sym
+          when :environment then @environment_source
+          when :server      then @server_source
+          when :manual      then @manual_source
+          when :yaml        then @yaml_source
+          when :default     then @default_source
+          end
+
+          remove_config(source)
         end
 
-        def remove_config(source=nil)
-          @config_stack.delete_if do |c|
-            if block_given?
-              yield c
-            else
-              c.class == source.class && c == source
-            end
+        def remove_config(source)
+          case source
+          when EnvironmentSource then @environment_source = nil
+          when ServerSource      then @server_source      = nil
+          when ManualSource      then @manual_source      = nil
+          when YamlSource        then @yaml_source        = nil
+          when DefaultSource     then @default_source     = nil
+          else
+            @configs_for_testing.delete_if {|src,lvl| src == source}
           end
 
           reset_cache
@@ -55,18 +78,29 @@ module NewRelic
           log_config(:remove, source)
         end
 
-        def replace_or_add_config(source, level=0)
-          index = config_stack_index_for(source.class)
-          @config_stack.delete_at(index) if index
-          apply_config(source, index || level)
-        end
+        def replace_or_add_config(source)
+          source.freeze
+          was_finished = finished_configuring?
+
+          invoke_callbacks(:add, source)
+          case source
+          when EnvironmentSource then @environment_source = source
+          when ServerSource      then @server_source      = source
+          when ManualSource      then @manual_source      = source
+          when YamlSource        then @yaml_source        = source
+          when DefaultSource     then @default_source     = source
+          else
+            NewRelic::Agent.logger.warn("Invalid config format; config will be ignored: #{source}")
+          end
 
-        def config_stack_index_for(source_class)
-          @config_stack.map{|s| s.class}.index(source_class)
+          reset_cache
+          log_config(:add, source)
+
+          notify_finished_configuring if !was_finished && finished_configuring?
         end
 
         def source(key)
-          @config_stack.each do |config|
+          config_stack.each do |config|
             if config.respond_to?(key.to_sym) || config.has_key?(key.to_sym)
               return config
             end
@@ -74,7 +108,7 @@ module NewRelic
         end
 
         def fetch(key)
-          @config_stack.each do |config|
+          config_stack.each do |config|
             next unless config
             accessor = key.to_sym
             if config.has_key?(accessor)
@@ -113,11 +147,11 @@ module NewRelic
         end
 
         def finished_configuring?
-          @config_stack.any? {|s| s.is_a?(ServerSource)}
+          !@server_source.nil?
         end
 
         def flattened
-          @config_stack.reverse.inject({}) do |flat,layer|
+          config_stack.reverse.inject({}) do |flat,layer|
             thawed_layer = layer.to_hash.dup
             thawed_layer.each do |k,v|
               begin
@@ -153,7 +187,14 @@ module NewRelic
 
         # Generally only useful during initial construction and tests
         def reset_to_defaults
-          @config_stack = [ EnvironmentSource.new, DefaultSource.new ]
+          @environment_source  = EnvironmentSource.new
+          @server_source       = nil
+          @manual_source       = nil
+          @yaml_source         = nil
+          @default_source      = DefaultSource.new
+
+          @configs_for_testing = []
+
           reset_cache
         end
 
@@ -171,8 +212,41 @@ module NewRelic
           end
         end
 
+        def delete_all_configs_for_testing
+          @environment_source  = nil
+          @server_source       = nil
+          @manual_source       = nil
+          @yaml_source         = nil
+          @default_source      = nil
+          @configs_for_testing = []
+        end
+
+        def num_configs_for_testing
+          config_stack.size
+        end
+
+        def config_classes_for_testing
+          config_stack.map(&:class)
+        end
+
         private
 
+        def config_stack
+          stack = [@environment_source,
+                   @server_source,
+                   @manual_source,
+                   @yaml_source,
+                   @default_source]
+
+          stack.compact!
+
+          @configs_for_testing.each do |config, index|
+            stack.insert(index, config)
+          end
+
+          stack
+        end
+
         def parse_constant_list(list)
           list.split(/\s*,\s*/).map do |class_name|
             const = constantize(class_name)

data/lib/new_relic/agent/cross_app_monitor.rb

@@ -2,7 +2,6 @@
 # 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/rack/agent_hooks'
 require 'new_relic/agent/transaction_state'
 require 'new_relic/agent/threading/agent_thread'
 
@@ -48,23 +47,26 @@ module NewRelic
           debug("Wiring up Cross Application Tracing to events after finished configuring")
 
         events = Agent.instance.events
-        events.subscribe(:before_call) do |env|
+        events.subscribe(:before_call) do |env| #THREAD_LOCAL_ACCESS
           if should_process_request(env)
-            save_client_cross_app_id(env)
-            save_referring_transaction_info(env)
+            state = NewRelic::Agent::TransactionState.tl_get
+
+            save_client_cross_app_id(state, env)
+            save_referring_transaction_info(state, env)
+            set_transaction_custom_parameters(state)
           end
         end
 
-        events.subscribe(:start_transaction) do
-          set_transaction_custom_parameters
-        end
+        events.subscribe(:after_call) do |env, (status_code, headers, body)| #THREAD_LOCAL_ACCESS
+          state = NewRelic::Agent::TransactionState.tl_get
 
-        events.subscribe(:after_call) do |env, (status_code, headers, body)|
-          insert_response_header(env, headers)
+          insert_response_header(state, env, headers)
         end
 
-        events.subscribe(:notice_error) do |_, options|
-          set_error_custom_parameters(options)
+        events.subscribe(:notice_error) do |_, options| #THREAD_LOCAL_ACCESS
+          state = NewRelic::Agent::TransactionState.tl_get
+
+          set_error_custom_parameters(state, options)
         end
       end
 
@@ -73,50 +75,46 @@ module NewRelic
         @obfuscator = NewRelic::Agent::Obfuscator.new(NewRelic::Agent.config[:encoding_key])
       end
 
-      def save_client_cross_app_id(request_headers)
-        TransactionState.get.client_cross_app_id = decoded_id(request_headers)
+      def save_client_cross_app_id(state, request_headers)
+        state.client_cross_app_id = decoded_id(request_headers)
       end
 
-      def clear_client_cross_app_id
-        TransactionState.get.client_cross_app_id = nil
+      def clear_client_cross_app_id(state)
+        state.client_cross_app_id = nil
       end
 
-      def client_cross_app_id
-        TransactionState.get.client_cross_app_id
-      end
+      def save_referring_transaction_info(state, request_headers)
+        txn_header = from_headers(request_headers, NEWRELIC_TXN_HEADER_KEYS) or return
+        txn_header = obfuscator.deobfuscate(txn_header)
+        txn_info = NewRelic::JSONWrapper.load(txn_header)
+        NewRelic::Agent.logger.debug("Referring txn_info: %p" % [txn_info])
 
-      def save_referring_transaction_info(request_headers)
-        txn_header = from_headers( request_headers, NEWRELIC_TXN_HEADER_KEYS ) or return
-        txn_header = obfuscator.deobfuscate( txn_header )
-        txn_info = NewRelic::JSONWrapper.load( txn_header )
-        NewRelic::Agent.logger.debug "Referring txn_info: %p" % [ txn_info ]
-
-        TransactionState.get.referring_transaction_info = txn_info
+        state.referring_transaction_info = txn_info
       end
 
-      def client_referring_transaction_guid
-        info = TransactionState.get.referring_transaction_info or return nil
+      def client_referring_transaction_guid(state)
+        info = state.referring_transaction_info or return nil
         return info[0]
       end
 
-      def client_referring_transaction_record_flag
-        info = TransactionState.get.referring_transaction_info or return nil
+      def client_referring_transaction_record_flag(state)
+        info = state.referring_transaction_info or return nil
         return info[1]
       end
 
-      def insert_response_header(request_headers, response_headers)
-        unless client_cross_app_id.nil?
-          txn = NewRelic::Agent::TransactionState.get.most_recent_transaction
+      def insert_response_header(state, request_headers, response_headers)
+        unless state.client_cross_app_id.nil?
+          txn = state.current_transaction
           unless txn.nil?
             txn.freeze_name_and_execute_if_not_ignored do
-              timings = NewRelic::Agent::TransactionState.get.timings
+              timings = state.timings
               content_length = content_length_from_request(request_headers)
 
-              set_response_headers(response_headers, timings, content_length)
-              set_metrics(client_cross_app_id, timings)
+              set_response_headers(state, response_headers, timings, content_length)
+              set_metrics(state.client_cross_app_id, timings)
             end
           end
-          clear_client_cross_app_id
+          clear_client_cross_app_id(state)
         end
       end
 
@@ -137,37 +135,36 @@ module NewRelic
         NewRelic::Agent.config[:trusted_account_ids].include?(split_id.captures.first.to_i)
       end
 
-      def set_response_headers(response_headers, timings, content_length)
-        response_headers[NEWRELIC_APPDATA_HEADER] = build_payload(timings, content_length)
+      def set_response_headers(state, response_headers, timings, content_length)
+        response_headers[NEWRELIC_APPDATA_HEADER] = build_payload(state, timings, content_length)
       end
 
-      def build_payload(timings, content_length)
+      def build_payload(state, timings, content_length)
         payload = [
           NewRelic::Agent.config[:cross_process_id],
           timings.transaction_name,
           timings.queue_time_in_seconds.to_f,
           timings.app_time_in_seconds.to_f,
           content_length,
-          transaction_guid()
+          state.request_guid
         ]
         payload = obfuscator.obfuscate(NewRelic::JSONWrapper.dump(payload))
       end
 
-      def set_transaction_custom_parameters
+      def set_transaction_custom_parameters(state)
         # We expect to get the before call to set the id (if we have it) before
         # this, and then write our custom parameter when the transaction starts
-        NewRelic::Agent.add_custom_parameters(:client_cross_process_id => client_cross_app_id()) if client_cross_app_id()
+        NewRelic::Agent.add_custom_parameters(:client_cross_process_id => state.client_cross_app_id) if state.client_cross_app_id
 
-        referring_guid = client_referring_transaction_guid()
+        referring_guid = client_referring_transaction_guid(state)
         if referring_guid
           NewRelic::Agent.logger.debug "Referring transaction guid: %p" % [referring_guid]
           NewRelic::Agent.add_custom_parameters(:referring_transaction_guid => referring_guid)
         end
       end
 
-      def set_error_custom_parameters(options)
-        options[:client_cross_process_id] = client_cross_app_id() if client_cross_app_id()
-        # [MG] TODO: Should the CAT metrics be set here too?
+      def set_error_custom_parameters(state, options)
+        options[:client_cross_process_id] = state.client_cross_app_id if state.client_cross_app_id
       end
 
       def set_metrics(id, timings)
@@ -186,10 +183,6 @@ module NewRelic
         from_headers(request, CONTENT_LENGTH_HEADER_KEYS) || -1
       end
 
-      def transaction_guid
-        NewRelic::Agent::TransactionState.get.request_guid
-      end
-
       private
 
       def from_headers(request, try_keys)