wd_newrelic_rpm 3.3.4.1 → 3.5.5

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

@@ -0,0 +1,10 @@
+module NewRelic
+  module Agent
+    module Configuration
+      MASK_DEFAULTS = {
+        :'thread_profiler' =>         Proc.new { !NewRelic::Agent::ThreadProfiler.is_supported? },
+        :'thread_profiler.enabled' => Proc.new { !NewRelic::Agent::ThreadProfiler.is_supported? },
+      }
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module NewRelic
+  module Agent
+    module Configuration
+      class ServerSource < DottedHash
+        def initialize(hash)
+          if hash['agent_config']
+            if hash['agent_config']['transaction_tracer.transaction_threshold'] =~ /apdex_f/i
+              # when value is "apdex_f" remove the config and defer to default
+              hash['agent_config'].delete('transaction_tracer.transaction_threshold')
+            end
+            super(hash.delete('agent_config'))
+          end
+
+          string_map = [
+             ['collect_traces', 'transaction_tracer.enabled'],
+             ['collect_traces', 'slow_sql.enabled'],
+             ['collect_errors', 'error_collector.enabled']
+          ].each do |pair|
+            hash[pair[1]] = hash[pair[0]] if hash[pair[0]] != nil
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'new_relic/agent/configuration'
+
+module NewRelic
+  module Agent
+    module Configuration
+      class YamlSource < DottedHash
+        attr_accessor :file_path
+
+        def initialize(path, env)
+          ::NewRelic::Agent.logger.debug("Reading configuration from #{path}")
+
+          config = {}
+          begin
+            @file_path = File.expand_path(path)
+            if !File.exists?(@file_path)
+              ::NewRelic::Agent.logger.error("Unable to load configuration from #{path}")
+              return
+            end
+
+            file = File.read(@file_path)
+
+            # Next two are for populating the newrelic.yml via erb binding, necessary
+            # when using the default newrelic.yml file
+            generated_for_user = ''
+            license_key = ''
+
+            erb = ERB.new(file).result(binding)
+            config = merge!(YAML.load(erb)[env] || {})
+          rescue ScriptError, StandardError => e
+            ::NewRelic::Agent.logger.error("Unable to read configuration file #{path}: #{e}")
+          end
+
+          if config['transaction_tracer'] &&
+              config['transaction_tracer']['transaction_threshold'] =~ /apdex_f/i
+            # when value is "apdex_f" remove the config and defer to default
+            config['transaction_tracer'].delete('transaction_threshold')
+          end
+
+          booleanify_values(config, 'agent_enabled', 'enabled', 'monitor_daemons')
+
+          super(config)
+        end
+
+        protected
+
+        def booleanify_values(config, *keys)
+          # auto means defer ro default
+          keys.each do |option|
+            if config[option] == 'auto'
+              config.delete(option)
+            elsif !config[option].nil? && !is_boolean?(config[option])
+              config[option] = !!(config[option] =~ /yes|on|true/i)
+            end
+          end
+        end
+
+        def is_boolean?(value)
+          value == !!value
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/cross_process_monitoring.rb

@@ -0,0 +1,43 @@
+module NewRelic
+  module Agent
+    module CrossProcessMonitoring
+
+      module_function
+
+      def insert_response_header(request, response)
+        if Agent.config[:'cross_process.enabled'] &&
+            NewRelic::Agent.instance.cross_process_id && (id = id_from_request(request))
+
+          content_length = -1
+          timings = NewRelic::Agent::BrowserMonitoring.timings
+
+          # FIXME the transaction name might not be properly encoded.  use a json generator
+          payload = %[["#{NewRelic::Agent.instance.cross_process_id}","#{timings.transaction_name}",#{timings.queue_time_in_millis},#{timings.app_time_in_millis},#{content_length}] ]
+          payload = obfuscate_with_key(payload, NewRelic::Agent.instance.cross_process_encoding_bytes)
+
+          response['X-NewRelic-App-Data'] = payload
+          #FIXME generate ClientApplication metric.  id must be decoded first
+          # String metricName = MessageFormat.format("ClientApplication/{0}/all", id);
+        end
+      end
+
+      def obfuscate_with_key(text, key_bytes)
+        obfuscated = ""
+        index = 0
+        text.each_byte{|byte|
+          obfuscated.concat((byte ^ key_bytes[index % key_bytes.length].to_i))
+          index+=1
+        }
+
+        [obfuscated].pack("m0").gsub("\n", '')
+      end
+
+      def id_from_request(request)
+        %w{X-NewRelic-ID HTTP_X_NEWRELIC_ID X_NEWRELIC_ID}.each do |header|
+          return request.env[header] if request.env.has_key?(header)
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/new_relic/agent/database.rb

@@ -14,27 +14,42 @@ module NewRelic
                            "Rows",
                            "Extra"
                           ].freeze
-  
+
   module Agent
     module Database
       extend self
-      
+
       def obfuscate_sql(sql)
         Obfuscator.instance.obfuscator.call(sql)
       end
-      
+
       def set_sql_obfuscator(type, &block)
         Obfuscator.instance.set_sql_obfuscator(type, &block)
       end
-      
+
+      def record_sql_method
+        case Agent.config[:'transaction_tracer.record_sql'].to_s
+        when 'off'
+          :off
+        when 'none'
+          :off
+        when 'false'
+          :off
+        when 'raw'
+          :raw
+        else
+          :obfuscated
+        end
+      end
+
       def get_connection(config)
         ConnectionManager.instance.get_connection(config)
       end
-      
+
       def close_connections
         ConnectionManager.instance.close_connections
       end
-      
+
       # Perform this in the runtime environment of a managed
       # application, to explain the sql statement executed within a
       # segment of a transaction sample. Returns an array of
@@ -50,7 +65,7 @@ module NewRelic
         explain_sql = explain_statement(statement, connection_config)
         return explain_sql || []
       end
-      
+
       def explain_statement(statement, config)
         if is_select?(statement)
           handle_exception_in_explain do
@@ -63,12 +78,12 @@ module NewRelic
           end
         end
       end
-      
+
       def process_resultset(items)
         # The resultset type varies for different drivers.  Only thing you can count on is
         # that it implements each.  Also: can't use select_rows because the native postgres
         # driver doesn't know that method.
-        
+
         headers = []
         values = []
         if items.respond_to?(:each_hash)
@@ -88,7 +103,7 @@ module NewRelic
         else
           values = [items]
         end
-        
+
         headers = nil if headers.empty?
         [headers, values]
       end
@@ -98,20 +113,19 @@ module NewRelic
       rescue => e
         begin
           # guarantees no throw from explain_sql
-          NewRelic::Control.instance.log.error("Error getting query plan: #{e.message}")
-          NewRelic::Control.instance.log.debug(e.backtrace.join("\n"))
+          ::NewRelic::Agent.logger.error("Error getting query plan:", e)
         rescue
           # double exception. throw up your hands
         end
       end
-      
+
       def is_select?(statement)
         # split the string into at most two segments on the
         # system-defined field separator character
         first_word, rest_of_statement = statement.split($;, 2)
         (first_word.upcase == 'SELECT')
       end
-      
+
       class ConnectionManager
         include Singleton
 
@@ -121,21 +135,20 @@ module NewRelic
         # the sql
         def get_connection(config)
           @connections ||= {}
-          
+
           connection = @connections[config]
-          
+
           return connection if connection
-          
+
           begin
             connection = ActiveRecord::Base.send("#{config[:adapter]}_connection", config)
             @connections[config] = connection
           rescue => e
-            NewRelic::Agent.agent.log.error("Caught exception #{e} trying to get connection to DB for explain. Control: #{config}")
-            NewRelic::Agent.agent.log.error(e.backtrace.join("\n"))
+            ::NewRelic::Agent.logger.error("Caught exception trying to get connection to DB for explain. Control: #{config}", e)
             nil
           end
         end
-        
+
         # Closes all the connections in the internal connection cache
         def close_connections
           @connections ||= {}
@@ -145,16 +158,16 @@ module NewRelic
             rescue
             end
           end
-          
+
           @connections = {}
         end
       end
 
       class Obfuscator
         include Singleton
-        
+
         attr_reader :obfuscator
-        
+
         def initialize
           reset
         end
@@ -162,7 +175,7 @@ module NewRelic
         def reset
           @obfuscator = method(:default_sql_obfuscator)
         end
-        
+
         # Sets the sql obfuscator used to clean up sql when sending it
         # to the server. Possible types are:
         #
@@ -185,7 +198,7 @@ module NewRelic
             fail "unknown sql_obfuscator type #{type}"
           end
         end
-        
+
         def default_sql_obfuscator(sql)
           stmt = sql.kind_of?(Statement) ? sql : Statement.new(sql)
           adapter = stmt.adapter
@@ -215,7 +228,7 @@ module NewRelic
         end
       end
 
-      class Statement < String        
+      class Statement < String
         attr_accessor :adapter
       end
     end

data/lib/new_relic/agent/error_collector.rb

@@ -10,38 +10,43 @@ module NewRelic
       module Shim #:nodoc:
         def notice_error(*args); end
       end
-      
+
       # Maximum possible length of the queue - defaults to 20, may be
       # made configurable in the future. This is a tradeoff between
       # memory and data retention
       MAX_ERROR_QUEUE_LENGTH = 20 unless defined? MAX_ERROR_QUEUE_LENGTH
 
-      attr_accessor :enabled
-      attr_reader :config_enabled
-      
+      attr_accessor :errors
+
       # Returns a new error collector
       def initialize
         @errors = []
         # lookup of exception class names to ignore.  Hash for fast access
         @ignore = {}
+        @capture_source = Agent.config[:'error_collector.capture_source']
 
-        config = NewRelic::Control.instance.fetch('error_collector', {})
-
-        @enabled = @config_enabled = config.fetch('enabled', true)
-        @capture_source = config.fetch('capture_source', true)
+        initialize_ignored_errors(Agent.config[:'error_collector.ignore_errors'])
+        @lock = Mutex.new
 
-        ignore_errors = config.fetch('ignore_errors', "")
+        Agent.config.register_callback(:'error_collector.enabled') do |config_enabled|
+          ::NewRelic::Agent.logger.debug "Errors will #{config_enabled ? '' : 'not '}be sent to the New Relic service."
+        end
+        Agent.config.register_callback(:'error_collector.ignore_errors') do |ignore_errors|
+          initialize_ignored_errors(ignore_errors)
+        end
+      end
+      
+      def initialize_ignored_errors(ignore_errors)
+        @ignore.clear
         ignore_errors = ignore_errors.split(",") if ignore_errors.is_a? String
         ignore_errors.each { |error| error.strip! }
         ignore(ignore_errors)
-        @lock = Mutex.new
       end
-      
-      # Helper method to get the NewRelic::Control.instance
-      def control
-        NewRelic::Control.instance
+
+      def enabled?
+        Agent.config[:'error_collector.enabled']
       end
-      
+
       # Returns the error filter proc that is used to check if an
       # error should be reported. When given a block, resets the
       # filter to the provided block.  The define_method() is used to
@@ -59,45 +64,43 @@ module NewRelic
       # errors is an array of Exception Class Names
       #
       def ignore(errors)
-        errors.each { |error| @ignore[error] = true; log.debug("Ignoring errors of type '#{error}'") }
+        errors.each do |error|
+          @ignore[error] = true
+          ::NewRelic::Agent.logger.debug("Ignoring errors of type '#{error}'")
+        end
       end
-      
+
       # This module was extracted from the notice_error method - it is
       # internally tested and can be refactored without major issues.
       module NoticeError
-        # Whether the error collector is disabled or not
-        def disabled?
-          !@enabled
-        end
-        
         # Checks the provided error against the error filter, if there
         # is an error filter
         def filtered_by_error_filter?(error)
           return unless @ignore_filter
           !@ignore_filter.call(error)
         end
-        
+
         # Checks the array of error names and the error filter against
         # the provided error
         def filtered_error?(error)
           @ignore[error.class.name] || filtered_by_error_filter?(error)
         end
-        
+
         # an error is ignored if it is nil or if it is filtered
         def error_is_ignored?(error)
           error && filtered_error?(error)
         end
-        
+
         # Increments a statistic that tracks total error rate
         def increment_error_count!
           NewRelic::Agent.get_stats("Errors/all").increment_count
         end
-        
+
         # whether we should return early from the notice_error process
         # - based on whether the error is ignored or the error
         # collector is disabled
         def should_exit_notice_error?(exception)
-          if @enabled
+          if enabled?
             if !error_is_ignored?(exception)
               increment_error_count!
               return exception.nil? # exit early if the exception is nil
@@ -106,40 +109,40 @@ module NewRelic
           # disabled or an ignored error, per above
           true
         end
-        
+
         # acts just like Hash#fetch, but deletes the key from the hash
         def fetch_from_options(options, key, default=nil)
           options.delete(key) || default
         end
-        
+
         # returns some basic option defaults pulled from the provided
         # options hash
         def uri_ref_and_root(options)
           {
             :request_uri => fetch_from_options(options, :uri, ''),
             :request_referer => fetch_from_options(options, :referer, ''),
-            :rails_root => control.root
+            :rails_root => NewRelic::Control.instance.root
           }
         end
-        
+
         # If anything else is left over, we treat it like a custom param
         def custom_params_from_opts(options)
           # If anything else is left over, treat it like a custom param:
           fetch_from_options(options, :custom_params, {}).merge(options)
         end
-        
+
         # takes the request parameters out of the options hash, and
         # returns them if we are capturing parameters, otherwise
         # returns nil
         def request_params_from_opts(options)
           value = options.delete(:request_params)
-          if control.capture_params
+          if Agent.config[:capture_params]
             value
           else
             nil
           end
         end
-        
+
         # normalizes the request and custom parameters before attaching
         # them to the error. See NewRelic::CollectionHelper#normalize_params
         def normalized_request_and_custom_params(options)
@@ -148,32 +151,32 @@ module NewRelic
             :custom_params  => normalize_params(custom_params_from_opts(options))
           }
         end
-        
+
         # Merges together many of the options into something that can
         # actually be attached to the error
         def error_params_from_options(options)
           uri_ref_and_root(options).merge(normalized_request_and_custom_params(options))
         end
-        
+
         # calls a method on an object, if it responds to it - used for
         # detection and soft fail-safe. Returns nil if the method does
         # not exist
         def sense_method(object, method)
           object.send(method) if object.respond_to?(method)
         end
-        
+
         # extracts source from the exception, if the exception supports
         # that method
         def extract_source(exception)
           sense_method(exception, 'source_extract') if @capture_source
         end
-        
+
         # extracts a stack trace from the exception for debugging purposes
         def extract_stack_trace(exception)
           actual_exception = sense_method(exception, 'original_exception') || exception
           sense_method(actual_exception, 'backtrace') || '<no stack trace>'
         end
-        
+
         # extracts a bunch of information from the exception to include
         # in the noticed error - some may or may not be available, but
         # we try to include all of it
@@ -185,22 +188,23 @@ module NewRelic
             :stack_trace => extract_stack_trace(exception)
           }
         end
-        
+
         # checks the size of the error queue to make sure we are under
         # the maximum limit, and logs a warning if we are over the limit.
         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 New Relic until the queued errors have been sent: #{message}") if over_limit
+          ::NewRelic::Agent.logger.warn("The error reporting queue has reached #{MAX_ERROR_QUEUE_LENGTH}. The error detail for this and subsequent errors will not be transmitted to New Relic until the queued errors have been sent: #{message}") if over_limit
           over_limit
         end
 
-        
         # Synchronizes adding an error to the error queue, and checks if
         # the error queue is too long - if so, we drop the error on the
         # floor after logging a warning.
         def add_to_error_queue(noticed_error)
           @lock.synchronize do
-            @errors << noticed_error unless over_queue_limit?(noticed_error.message)
+            if !over_queue_limit?(noticed_error.message) && !@errors.include?(noticed_error)
+              @errors << noticed_error
+            end
           end
         end
       end
@@ -224,7 +228,7 @@ module NewRelic
         add_to_error_queue(NewRelic::NoticedError.new(action_path, exception_options, exception))
         exception
       rescue => e
-        log.error("Error capturing an error, yodawg. #{e}")
+        ::NewRelic::Agent.logger.warn("Failure when capturing error '#{exception}':", e)
       end
 
       # Get the errors currently queued up.  Unsent errors are left
@@ -241,11 +245,6 @@ module NewRelic
           errors
         end
       end
-
-      private
-      def log
-        NewRelic::Agent.logger
-      end
     end
   end
 end