ghazel-newrelic_rpm 3.4.0.2 → 3.5.4

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

@@ -7,7 +7,7 @@ module NewRelic
       #
       # New Relic will instrument a #call method as if it were a controller
       # action, collecting transaction traces and errors.  The middleware will
-      # be identified only by it's class, so if you want to instrument multiple
+      # be identified only by its class, so if you want to instrument multiple
       # actions in a middleware, you need to use
       # NewRelic::Agent::Instrumentation::ControllerInstrumentation::ClassMethods#add_transaction_tracer
       #

data/lib/new_relic/agent/instrumentation/rails/action_controller.rb

@@ -2,7 +2,7 @@ DependencyDetection.defer do
   @name = :rails21_view
   
   depends_on do
-    !NewRelic::Control.instance['disable_view_instrumentation'] &&
+    !NewRelic::Agent.config[:disable_view_instrumentation] &&
     defined?(ActionController) && defined?(ActionController::Base) && defined?(ActionView::PartialTemplate) && defined?(ActionView::Template) &&
     defined?(Rails::VERSION::STRING) && Rails::VERSION::STRING =~ /^2\.1\./   # Rails 2.1 &&
   end
@@ -26,7 +26,7 @@ DependencyDetection.defer do
   @name = :old_rails_view
   
   depends_on do
-    !NewRelic::Control.instance['disable_view_instrumentation'] &&
+    !NewRelic::Agent.config[:disable_view_instrumentation] &&
     defined?(ActionController) && defined?(ActionController::Base) &&
     defined?(Rails::VERSION::STRING) && Rails::VERSION::STRING =~ /^(1\.|2\.0)/  # Rails 1.* - 2.0 
   end
@@ -47,7 +47,7 @@ DependencyDetection.defer do
   @name = :rails23_view
   
   depends_on do
-    !NewRelic::Control.instance['disable_view_instrumentation'] &&
+    !NewRelic::Agent.config[:disable_view_instrumentation] &&
     defined?(ActionView) && defined?(ActionView::Template) && defined?(ActionView::RenderablePartial) &&
     defined?(Rails::VERSION::STRING) && Rails::VERSION::STRING =~ /^2\.[23]/ 
   end

data/lib/new_relic/agent/instrumentation/rails3/action_controller.rb

@@ -96,7 +96,7 @@ DependencyDetection.defer do
   end
 
   depends_on do
-    !NewRelic::Control.instance['disable_view_instrumentation']
+    !NewRelic::Agent.config[:disable_view_instrumentation]
   end
 
   executes do
@@ -135,7 +135,7 @@ DependencyDetection.defer do
   end
 
   depends_on do
-    !NewRelic::Control.instance['disable_view_instrumentation']
+    !NewRelic::Agent.config[:disable_view_instrumentation]
   end
 
   executes do

data/lib/new_relic/agent/instrumentation/rails3/errors.rb

@@ -6,7 +6,11 @@ module NewRelic
           def newrelic_notice_error(exception, custom_params = {})
             filtered_params = (respond_to? :filter_parameters) ? filter_parameters(params) : params
             filtered_params.merge!(custom_params)
-            NewRelic::Agent.agent.error_collector.notice_error(exception, request, newrelic_metric_path, filtered_params)
+            NewRelic::Agent::Instrumentation::MetricFrame.notice_error( \
+                exception, \
+                :request => request, \
+                :metric => newrelic_metric_path, \
+                :custom_params => filtered_params)
           end
         end
       end

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

@@ -2,7 +2,7 @@ DependencyDetection.defer do
   @name = :resque
   
   depends_on do
-    defined?(::Resque::Job) && !NewRelic::Control.instance['disable_resque']  &&
+    defined?(::Resque::Job) && !NewRelic::Agent.config[:disable_resque]  &&
       !NewRelic::LanguageSupport.using_version?('1.9.1')
   end
 

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

@@ -2,7 +2,7 @@ require 'new_relic/agent/instrumentation/controller_instrumentation'
 
 DependencyDetection.defer do
   @name = :sinatra
-  
+
   depends_on do
     defined?(::Sinatra) && defined?(::Sinatra::Base) &&
       Sinatra::Base.private_method_defined?(:dispatch!)
@@ -34,14 +34,14 @@ module NewRelic
       # will all be tracked as separate actions.
       module Sinatra
         include ::NewRelic::Agent::Instrumentation::ControllerInstrumentation
-                
+
         def dispatch_with_newrelic
           txn_name = NewRelic.transaction_name(self.class.routes, @request) do |pattern, keys, conditions|
             process_route(pattern, keys, conditions) do
               pattern.source
             end
           end
-          
+
           perform_action_with_newrelic_trace(:category => :sinatra,
                                              :name => txn_name,
                                              :params => @request.params) do
@@ -51,26 +51,30 @@ module NewRelic
 
         module NewRelic
           extend self
-          
+
           def http_verb(request)
             request.request_method if request.respond_to?(:request_method)
           end
-          
+
           def transaction_name(routes, request)
             name = '(unknown)'
             verb = http_verb(request)
-            
+
             Array(routes[verb]).each do |pattern, keys, conditions, block|
-              if pattern = yield(pattern, keys, conditions)
-                name = pattern
+              if route = yield(pattern, keys, conditions)
+                name = route
+                # it's important we short circuit here.  Otherwise we risk
+                # applying conditions from lower priority routes which can
+                # break the action.
+                break
               end
             end
-            
+
             name.gsub!(%r{^[/^]*(.*?)[/\$\?]*$}, '\1')
             if verb
               name = verb + ' ' + name
             end
-            
+
             name
           end
         end

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/method_tracer.rb

@@ -481,9 +481,13 @@ module NewRelic
 
           traced_method = code_to_eval(method_name, metric_name_code, options)
 
+          visibility = NewRelic::Helper.instance_method_visibility self, method_name
+
           class_eval traced_method, __FILE__, __LINE__
           alias_method _untraced_method_name(method_name, metric_name_code), method_name
           alias_method method_name, _traced_method_name(method_name, metric_name_code)
+          send visibility, method_name
+          send visibility, _traced_method_name(method_name, metric_name_code)
           NewRelic::Control.instance.log.debug("Traced method: class = #{self.name},"+
                     "method = #{method_name}, "+
                     "metric = '#{metric_name_code}'")
@@ -493,7 +497,7 @@ module NewRelic
         # from when they were added, or else other tracers that were added to the same method
         # may get removed as well.
         def remove_method_tracer(method_name, metric_name_code) # :nodoc:
-          return unless NewRelic::Control.instance.agent_enabled?
+          return unless Agent.config[:agent_enabled]
           if method_defined? "#{_traced_method_name(method_name, metric_name_code)}"
             alias_method method_name, "#{_untraced_method_name(method_name, metric_name_code)}"
             undef_method "#{_traced_method_name(method_name, metric_name_code)}"

data/lib/new_relic/agent/new_relic_service.rb

@@ -1,10 +1,13 @@
+require 'zlib'
+
 module NewRelic
   module Agent
     class NewRelicService
       # Specifies the version of the agent's communication protocol with
       # the NewRelic hosted site.
-      
-      PROTOCOL_VERSION = 8
+
+      PROTOCOL_VERSION = 10
+      # cf0d1ff1: v9 (tag 3.5.0)
       # 14105: v8 (tag 2.10.3)
       # (no v7)
       # 10379: v6 (not tagged)
@@ -12,20 +15,32 @@ 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=control.license_key, collector=control.server)
-        @license_key = license_key
+
+      attr_accessor :request_timeout, :agent_id
+      attr_reader :collector, :marshaller
+
+      def initialize(license_key=nil, collector=control.server)
+        @license_key = license_key || Agent.config[:license_key]
         @collector = collector
-        @request_timeout = NewRelic::Control.instance.fetch('timeout', 2 * 60)
+        @request_timeout = Agent.config[:timeout]
+        load_marshaller
       end
-      
+
+      def load_marshaller
+        if Agent.config[:marshaller] == :json
+          require 'json'
+          @marshaller = JsonMarshaller.new
+        else
+          @marshaller = PrubyMarshaller.new
+        end
+      rescue LoadError
+        @marshaller = PrubyMarshaller.new
+      end
+
       def connect(settings={})
-        host = get_redirect_host
-        @collector.name = host if host
+        if host = get_redirect_host
+          @collector = NewRelic::Control.instance.server_from_host(host)
+        end
         response = invoke_remote(:connect, settings)
         @agent_id = response['agent_run_id']
         response
@@ -36,14 +51,14 @@ module NewRelic
       end
 
       def shutdown(time)
-        invoke_remote(:shutdown, @agent_id, time) if @agent_id
+        invoke_remote(:shutdown, @agent_id, time.to_i) if @agent_id
       end
 
       def metric_data(last_harvest_time, now, unsent_timeslice_data)
         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
@@ -56,50 +71,73 @@ module NewRelic
         invoke_remote(:sql_trace_data, sql_traces)
       end
 
+      def profile_data(profile)
+        invoke_remote(:profile_data, @agent_id, profile.to_compressed_array) || ''
+      end
+
+      def get_agent_commands
+        invoke_remote(:get_agent_commands, @agent_id)
+      end
+
+      def agent_command_results(command_id, error=nil)
+        results = {}
+        results["error"] = error unless error.nil?
+
+        invoke_remote(:agent_command_results, @agent_id, { command_id.to_s => results })
+      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)
+      def remote_method_uri(method, format='ruby')
+        params = {'run_id' => @agent_id, 'marshal_format' => format}
         uri = "/agent_listener/#{PROTOCOL_VERSION}/#{@license_key}/#{method}"
-        uri << "?run_id=#{@agent_id}" if @agent_id
+        uri << '?' + params.map do |k,v|
+          next unless v
+          "#{k}=#{v}"
+        end.compact.join('&')
         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
       # server may return
       def invoke_remote(method, *args)
         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,
-                                :data      => post_data)
-
-        # raises the right exception if the remote server tells it to die
-        return check_for_exception(response)
+
+        data = @marshaller.dump(args)
+        check_post_size(data)
+        response = send_request(:data      => data,
+                                :uri       => remote_method_uri(method,
+                                                          @marshaller.format),
+                                :encoding  => @marshaller.encoding,
+                                :collector => @collector)
+        @marshaller.load(decompress_response(response))
       rescue NewRelic::Agent::ForceRestartException => e
         log.info e.message
         raise
-      rescue SystemCallError, SocketError => e
-        # These include Errno connection errors
-        raise NewRelic::Agent::ServerConnectionException, "Recoverable error connecting to the server: #{e}"
       ensure
-        NewRelic::Agent.instance.stats_engine.get_stats_no_scope('Supportability/invoke_remote').record_data_point((Time.now - now).to_f)
-        NewRelic::Agent.instance.stats_engine.get_stats_no_scope('Supportability/invoke_remote/' + method.to_s).record_data_point((Time.now - now).to_f)
+        record_supportability_metrics(method, now)
+      end
+
+      def record_supportability_metrics(method, now)
+        NewRelic::Agent.instance.stats_engine. \
+          get_stats_no_scope('Supportability/invoke_remote'). \
+          record_data_point((Time.now - now).to_f)
+        NewRelic::Agent.instance.stats_engine. \
+          get_stats_no_scope('Supportability/invoke_remote/' + method.to_s). \
+          record_data_point((Time.now - now).to_f)
       end
 
       # This method handles the compression of the request body that
@@ -118,11 +156,9 @@ module NewRelic
       # big payloads get all the compression possible, to stay under
       # the 2,000,000 byte post threshold
       def compress_data(object)
-        dump = Marshal.dump(object)
+        dump = marshal_data(object)
 
-        dump_size = dump.size
-
-        return [dump, 'identity'] if dump_size < (64*1024)
+        return [dump, 'identity'] if dump.size < (64*1024)
 
         compressed_dump = Zlib::Deflate.deflate(dump, Zlib::DEFAULT_COMPRESSION)
 
@@ -132,13 +168,21 @@ module NewRelic
         [compressed_dump, 'deflate']
       end
 
-      # Raises a PostTooBigException if the post_string is longer
+      def marshal_data(data)
+        NewRelic::LanguageSupport.with_cautious_gc do
+          Marshal.dump(data)
+        end
+      rescue => e
+        log.debug("#{e.class.name} : #{e.message} when marshalling #{object}")
+        raise
+      end
+
+      # 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 < control.post_size_limit
-        log.warn "Tried to send too much data: #{post_string.size} bytes"
-        raise PostTooBigException
+        return if post_string.size < Agent.config[:post_size_limit]
+        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
@@ -156,9 +200,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
@@ -167,20 +211,27 @@ module NewRelic
             response = http.request(request)
           end
         rescue Timeout::Error
-          log.warn "Timed out trying to post data to New Relic (timeout = #{@request_timeout} seconds)" unless @service.request_timeout < 30
+          log.warn "Timed out trying to post data to New Relic (timeout = #{@request_timeout} seconds)" unless @request_timeout < 30
           raise
         end
-        if response.is_a? Net::HTTPServiceUnavailable
-          raise NewRelic::Agent::ServerConnectionException, "Service unavailable (#{response.code}): #{response.message}"
+        if response.is_a? Net::HTTPUnauthorized
+          raise LicenseException, 'Invalid license key, please contact support@newrelic.com'
+        elsif response.is_a? Net::HTTPServiceUnavailable
+          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
+      rescue SystemCallError, SocketError => e
+        # These include Errno connection errors
+        raise NewRelic::Agent::ServerConnectionException, "Recoverable error connecting to the server: #{e}"
       end
 
       # Decompresses the response from the server, if it is gzip
@@ -195,15 +246,6 @@ module NewRelic
         i.read
       end
 
-      # unmarshals the response and raises it if it is an exception,
-      # so we can handle it in nonlocally
-      def check_for_exception(response)
-        dump = decompress_response(response)
-        value = Marshal.load(dump)
-        raise value if value.is_a? Exception
-        value
-      end
-
       # Sets the user agent for connections to the server, to
       # conform with the HTTP spec and allow for debugging. Includes
       # the ruby version and also zlib version if available since
@@ -216,6 +258,134 @@ module NewRelic
         zlib_version << "zlib/#{Zlib.zlib_version}" if defined?(::Zlib) && Zlib.respond_to?(:zlib_version)
         "NewRelic-RubyAgent/#{NewRelic::VERSION::STRING} #{ruby_description}#{zlib_version}"
       end
+
+      class Marshaller
+        attr_reader :encoding
+
+        # This method handles the compression of the request body that
+        # we are going to send to the server
+        #
+        # We currently optimize for CPU here since we get roughly a 10x
+        # reduction in message size with this, and CPU overhead is at a
+        # premium. For extra-large posts, we use the higher compression
+        # since otherwise it actually errors out.
+        #
+        # We do not compress if content is smaller than 64kb.  There are
+        # problems with bugs in Ruby in some versions that expose us
+        # to a risk of segfaults if we compress aggressively.
+        #
+        # medium payloads get fast compression, to save CPU
+        # big payloads get all the compression possible, to stay under
+        # the 2,000,000 byte post threshold
+        def compress(data, opts={})
+          if opts[:force] || data.size > 64 * 1024
+            data = Zlib::Deflate.deflate(data, Zlib::DEFAULT_COMPRESSION)
+            @encoding = 'deflate'
+          else
+            @encoding = 'identity'
+          end
+          data
+        end
+
+        def parsed_error(error)
+          error_class = error['error_type'].split('::') \
+            .inject(Module) {|mod,const| mod.const_get(const) }
+          error_class.new(error['message'])
+        rescue NameError
+          CollectorError.new("#{error['error_type']}: #{error['message']}")
+        end
+
+        protected
+
+        def prepare(data)
+          if data.respond_to?(:to_collector_array)
+            data.to_collector_array(self)
+          elsif data.kind_of?(Array)
+            data.map {|element| prepare(element) }
+          else
+            data
+          end
+        end
+
+        def return_value(data)
+          if data.respond_to?(:has_key?)
+            if data.has_key?('exception')
+              raise parsed_error(data['exception'])
+            elsif data.has_key?('return_value')
+              return data['return_value']
+            end
+          end
+          NewRelic::Agent.logger.debug("Unexpected response from collector: #{data}")
+          nil
+        end
+      end
+
+      # Primitive Ruby Object Notation which complies JSON format data strutures
+      class PrubyMarshaller < Marshaller
+        def initialize
+          NewRelic::Agent.logger.debug 'Using Pruby marshaller'
+        end
+
+        def dump(ruby)
+          NewRelic::LanguageSupport.with_cautious_gc do
+            compress(Marshal.dump(prepare(ruby)))
+          end
+        rescue => e
+          NewRelic::Agent.logger.debug("#{e.class.name} : #{e.message} when marshalling #{ruby.inspect}")
+          raise
+        end
+
+        def load(data)
+          return unless data && data != ''
+          NewRelic::LanguageSupport.with_cautious_gc do
+            return_value(Marshal.load(data))
+          end
+        rescue
+          NewRelic::Agent.logger.debug "Error encountered loading collector response: #{data}"
+          raise
+        end
+
+        def format
+          'pruby'
+        end
+
+        def self.is_supported?
+          true
+        end
+      end
+
+      # Marshal collector protocol with JSON when available
+      class JsonMarshaller < Marshaller
+        def initialize
+          NewRelic::Agent.logger.debug 'Using JSON marshaller'
+        end
+
+        def dump(ruby)
+          compress(JSON.dump(prepare(ruby)))
+        end
+
+        def load(data)
+          return unless data && data != ''
+          return_value(JSON.load(data))
+        rescue
+          NewRelic::Agent.logger.debug "Error encountered loading collector response: #{data}"
+          raise
+        end
+
+        def encode_compress(data)
+          Base64.encode64(compress(JSON.dump(data), :force => true))
+        end
+
+        def format
+          'json'
+        end
+
+        def self.is_supported?
+          RUBY_VERSION >= '1.9.2'
+        end
+      end
+
+      class CollectorError < StandardError; end
     end
   end
 end