newrelic_rpm 3.4.2.1 → 3.5.0

data/lib/new_relic/agent/error_collector.rb

@@ -10,22 +10,19 @@ 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, :errors
-      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 = {}
-
-        @enabled = @config_enabled = Agent.config[:'error_collector.enabled']
         @capture_source = Agent.config[:'error_collector.capture_source']
 
         ignore_errors = Agent.config[:'error_collector.ignore_errors']
@@ -33,6 +30,14 @@ module NewRelic
         ignore_errors.each { |error| error.strip! }
         ignore(ignore_errors)
         @lock = Mutex.new
+
+        Agent.config.register_callback(:'error_collector.enabled') do |config_enabled|
+          log.debug "Errors will #{config_enabled ? '' : 'not '}be sent to the New Relic service."
+        end
+      end
+
+      def enabled?
+        Agent.config[:'error_collector.enabled']
       end
 
       # Returns the error filter proc that is used to check if an
@@ -57,43 +62,38 @@ module NewRelic
           log.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
@@ -102,12 +102,12 @@ 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)
@@ -117,13 +117,13 @@ module NewRelic
             :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
@@ -135,7 +135,7 @@ module NewRelic
             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)
@@ -144,32 +144,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
@@ -181,7 +181,7 @@ 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)
@@ -190,13 +190,14 @@ module NewRelic
           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
@@ -220,7 +221,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}")
+        log.error("Error capturing an error #{e}")
       end
 
       # Get the errors currently queued up.  Unsent errors are left

data/lib/new_relic/agent/instrumentation/unicorn_instrumentation.rb

@@ -4,15 +4,16 @@ DependencyDetection.defer do
   depends_on do
     defined?(::Unicorn) && defined?(::Unicorn::HttpServer)
   end
-  
+
   executes do
     NewRelic::Agent.logger.debug 'Installing Unicorn instrumentation'
+    NewRelic::Agent.logger.info 'Detected Unicorn, please see additional documentation: https://newrelic.com/docs/troubleshooting/im-using-unicorn-and-i-dont-see-any-data'
   end
-  
+
   executes do
     Unicorn::HttpServer.class_eval do
       old_worker_loop = instance_method(:worker_loop)
-      define_method(:worker_loop) do | worker |
+      define_method(:worker_loop) do |worker|
         NewRelic::Agent.after_fork(:force_reconnect => true)
         old_worker_loop.bind(self).call(worker)
       end

data/lib/new_relic/agent/new_relic_service.rb

@@ -3,8 +3,8 @@ module NewRelic
     class NewRelicService
       # Specifies the version of the agent's communication protocol with
       # the NewRelic hosted site.
-      
-      PROTOCOL_VERSION = 8
+
+      PROTOCOL_VERSION = 9
       # 14105: v8 (tag 2.10.3)
       # (no v7)
       # 10379: v6 (not tagged)
@@ -12,17 +12,17 @@ module NewRelic
       # 2292:  v4 (tag 2.3.6)
       # 1754:  v3 (tag 2.3.0)
       # 534:   v2 (shows up in 2.1.0, our first tag)
-      
+
       attr_accessor :request_timeout
       attr_reader :collector
       attr_accessor :agent_id
-      
+
       def initialize(license_key=nil, collector=control.server)
         @license_key = license_key || Agent.config[:license_key]
         @collector = collector
         @request_timeout = Agent.config[:timeout]
       end
-      
+
       def connect(settings={})
         if host = get_redirect_host
           @collector = NewRelic::Control.instance.server_from_host(host)
@@ -44,7 +44,7 @@ module NewRelic
         invoke_remote(:metric_data, @agent_id, last_harvest_time, now,
                       unsent_timeslice_data)
       end
-      
+
       def error_data(unsent_errors)
         invoke_remote(:error_data, @agent_id, unsent_errors)
       end
@@ -58,24 +58,24 @@ module NewRelic
       end
 
       private
-      
+
       # A shorthand for NewRelic::Control.instance
       def control
         NewRelic::Control.instance
       end
-      
+
       # Shorthand to the NewRelic::Agent.logger method
       def log
         NewRelic::Agent.logger
       end
-      
+
       # The path on the server that we should post our data to
       def remote_method_uri(method)
         uri = "/agent_listener/#{PROTOCOL_VERSION}/#{@license_key}/#{method}"
         uri << "?run_id=#{@agent_id}" if @agent_id
         uri
       end
-      
+
       # send a message via post to the actual server. This attempts
       # to automatically compress the data via zlib if it is large
       # enough to be worth compressing, and handles any errors the
@@ -84,7 +84,7 @@ module NewRelic
         now = Time.now
         #determines whether to zip the data or send plain
         post_data, encoding = compress_data(args)
-        
+
         response = send_request(:uri       => remote_method_uri(method),
                                 :encoding  => encoding,
                                 :collector => @collector,
@@ -140,13 +140,13 @@ module NewRelic
         raise
       end
 
-      # Raises a PostTooBigException if the post_string is longer
+      # Raises an UnrecoverableServerException if the post_string is longer
       # than the limit configured in the control object
       def check_post_size(post_string)
         # TODO: define this as a config option on the server side
         return if post_string.size < Agent.config[:post_size_limit]
-        log.warn "Tried to send too much data: #{post_string.size} bytes"
-        raise PostTooBigException
+        log.debug "Tried to send too much data: #{post_string.size} bytes"
+        raise UnrecoverableServerException.new('413 Request Entity Too Large')
       end
 
       # Posts to the specified server
@@ -164,9 +164,9 @@ module NewRelic
         request['user-agent'] = user_agent
         request.content_type = "application/octet-stream"
         request.body = opts[:data]
-        
+
         log.debug "Connect to #{opts[:collector]}#{opts[:uri]}"
-        
+
         response = nil
         http = control.http_connection(@collector)
         http.read_timeout = nil
@@ -179,14 +179,16 @@ module NewRelic
           raise
         end
         if response.is_a? Net::HTTPServiceUnavailable
-          raise NewRelic::Agent::ServerConnectionException, "Service unavailable (#{response.code}): #{response.message}"
+          raise ServerConnectionException, "Service unavailable (#{response.code}): #{response.message}"
         elsif response.is_a? Net::HTTPGatewayTimeOut
           log.debug("Timed out getting response: #{response.message}")
           raise Timeout::Error, response.message
         elsif response.is_a? Net::HTTPRequestEntityTooLarge
-          raise PostTooBigException
+          raise UnrecoverableServerException, '413 Request Entity Too Large'
+        elsif response.is_a? Net::HTTPUnsupportedMediaType
+          raise UnrecoverableServerException, '415 Unsupported Media Type'
         elsif !(response.is_a? Net::HTTPSuccess)
-          raise NewRelic::Agent::ServerConnectionException, "Unexpected response from server (#{response.code}): #{response.message}"
+          raise ServerConnectionException, "Unexpected response from server (#{response.code}): #{response.message}"
         end
         response
       end

data/lib/new_relic/agent/pipe_channel_manager.rb

@@ -17,15 +17,15 @@ module NewRelic
       def channels
         listener.pipes
       end
-      
+
       def listener
         @listener ||= Listener.new
       end
-      
+
       class Pipe
         attr_accessor :in, :out
         attr_reader :last_read
-        
+
         def initialize
           @out, @in = IO.pipe
           if defined?(::Encoding::ASCII_8BIT)
@@ -33,7 +33,7 @@ module NewRelic
           end
           @last_read = Time.now
         end
-        
+
         def close
           @out.close unless @out.closed?
           @in.close unless @in.closed?
@@ -46,7 +46,7 @@ module NewRelic
           end
           @in << "\n\n"
         end
-        
+
         def read
           @in.close unless @in.closed?
           @last_read = Time.now
@@ -57,7 +57,7 @@ module NewRelic
           @out.closed? && @in.closed?
         end
       end
-      
+
       class Listener
         attr_reader   :thread
         attr_accessor :pipes, :timeout, :select_timeout
@@ -80,7 +80,7 @@ module NewRelic
             loop do
               clean_up_pipes
               pipes_to_listen_to = @pipes.values.map{|pipe| pipe.out} + [wake.out]
-              if ready = IO.select(pipes_to_listen_to, [], [], @select_timeout) 
+              if ready = IO.select(pipes_to_listen_to, [], [], @select_timeout)
                 pipe = ready[0][0]
                 if pipe == wake.out
                   pipe.read(1)
@@ -88,14 +88,14 @@ module NewRelic
                   merge_data_from_pipe(pipe)
                 end
               end
-              
+
               break if !should_keep_listening?
             end
           end
           @thread #.abort_on_exception = true
           sleep 0.001 # give time for the thread to spawn
         end
-        
+
         def stop
           return unless @started == true
           @started = false
@@ -112,7 +112,7 @@ module NewRelic
           end
           @pipes = {}
         end
-        
+
         def wake
           @wake ||= Pipe.new
         end
@@ -126,7 +126,7 @@ module NewRelic
         def merge_data_from_pipe(pipe_handle)
           pipe = find_pipe_for_handle(pipe_handle)
           got = pipe.read
-          
+
           if got && !got.empty?
             payload = unmarshal(got)
             if payload == 'EOF'
@@ -148,11 +148,11 @@ module NewRelic
           NewRelic::Control.instance.log.debug(msg)
           nil
         end
-                
+
         def should_keep_listening?
           @started || @pipes.values.find{|pipe| !pipe.in.closed?}
         end
-        
+
         def clean_up_pipes
           @pipes.values.each do |pipe|
             if pipe.last_read.to_f + @timeout < Time.now.to_f

data/lib/new_relic/agent/sql_sampler.rb

@@ -18,7 +18,6 @@ module NewRelic
       attr_reader :sql_traces
 
       def initialize
-        configure!
         @sql_traces = {}
         clear_transaction_data
 
@@ -28,38 +27,20 @@ module NewRelic
         @samples_lock = Mutex.new
       end
 
-      def configure!
-        @explain_threshold = Agent.config[:'slow_sql.explain_threshold']
-        @explain_enabled = Agent.config[:'sloq_sql.explain_enabled']
-        @stack_trace_threshold = Agent.config[:'slow_sql.stack_trace_threshold']
-        if Agent.config[:'slow_sql.enabled']
-          enable
-        else
-          disable
-        end
-      end
-
-      # Enable the sql sampler - this also registers it with
-      # the statistics engine.
-      def enable
-        @disabled = false
-      end
-
-      # Disable the sql sampler - this also deregisters it
-      # with the statistics engine.
-      def disable
-        @disabled = true
-      end
-
       def enabled?
-        !@disabled
+        Agent.config[:'slow_sql.enabled'] &&
+          (Agent.config[:'slow_sql.record_sql'] == 'raw' ||
+           Agent.config[:'slow_sql.record_sql'] == 'obfuscated') &&
+          Agent.config[:'transaction_tracer.enabled']
       end
 
       def notice_transaction(path, uri=nil, params={})
         if NewRelic::Agent.instance.transaction_sampler.builder
           guid = NewRelic::Agent.instance.transaction_sampler.builder.sample.guid
         end
-        transaction_data.set_transaction_info(path, uri, params, guid) if !disabled && transaction_data
+        if Agent.config[:'slow_sql.enabled'] && transaction_data
+          transaction_data.set_transaction_info(path, uri, params, guid)
+        end
       end
 
       def notice_first_scope_push(time)
@@ -111,7 +92,7 @@ module NewRelic
       def notice_sql(sql, metric_name, config, duration)
         return unless transaction_data
         if NewRelic::Agent.is_sql_recorded?
-          if duration > @explain_threshold
+          if duration > Agent.config[:'slow_sql.explain_threshold']
             backtrace = caller.join("\n")
             transaction_data.sql_data << SlowSql.new(sql, metric_name, config,
                                                      duration, backtrace)
@@ -127,7 +108,7 @@ module NewRelic
       end
 
       def harvest
-        return [] if disabled
+        return [] if !Agent.config[:'slow_sql.enabled']
         result = []
         @samples_lock.synchronize do
           result = @sql_traces.values