newrelic_rpm 3.7.1.188 → 3.7.2.190.beta

data/lib/new_relic/agent/new_relic_service.rb

@@ -159,7 +159,6 @@ module NewRelic
 
       # Send fine-grained analytic data to the collector.
       def analytic_event_data(data)
-        data = data.map { |hash| [hash] }
         invoke_remote(:analytic_event_data, @agent_id, data)
       end
 
@@ -279,15 +278,15 @@ module NewRelic
       # enough to be worth compressing, and handles any errors the
       # server may return
       def invoke_remote(method, *args)
-        now = Time.now
+        start_ts = Time.now
 
-        data, size = nil
+        data, size, serialize_finish_ts = nil
         begin
           data = @marshaller.dump(args)
-        rescue JsonError
-          @marshaller = PrubyMarshaller.new
-          retry
+        rescue => e
+          handle_serialization_error(method, e)
         end
+        serialize_finish_ts = Time.now
 
         data, encoding = compress_request_if_needed(data)
         size = data.size
@@ -301,20 +300,31 @@ module NewRelic
                                 :encoding  => encoding,
                                 :collector => @collector)
         @marshaller.load(decompress_response(response))
-      rescue NewRelic::Agent::ForceRestartException => e
-        ::NewRelic::Agent.logger.debug e.message
-        raise
       ensure
-        record_supportability_metrics(method, now, size)
+        record_supportability_metrics(method, start_ts, serialize_finish_ts, size)
+      end
+
+      def handle_serialization_error(method, e)
+        NewRelic::Agent.increment_metric("Supportability/serialization_failure")
+        NewRelic::Agent.increment_metric("Supportability/serialization_failure/#{method}")
+        msg = "Failed to serialize #{method} data using #{@marshaller.class.to_s}: #{e.inspect}"
+        error = SerializationError.new(msg)
+        error.set_backtrace(e.backtrace)
+        raise error
       end
 
-      def record_supportability_metrics(method, now, size)
-        duration = (Time.now - now).to_f
-        NewRelic::Agent.record_metric('Supportability/invoke_remote', duration)
-        NewRelic::Agent.record_metric('Supportability/invoke_remote/' + method.to_s, duration)
+      def record_supportability_metrics(method, start_ts, serialize_finish_ts, size)
+        serialize_time = serialize_finish_ts && (serialize_finish_ts - start_ts)
+        duration = (Time.now - start_ts).to_f
+        NewRelic::Agent.record_metric("Supportability/invoke_remote", duration)
+        NewRelic::Agent.record_metric("Supportability/invoke_remote/#{method.to_s}", duration)
+        if serialize_time
+          NewRelic::Agent.record_metric("Supportability/invoke_remote_serialize", serialize_time)
+          NewRelic::Agent.record_metric("Supportability/invoke_remote_serialize/#{method.to_s}", serialize_time)
+        end
         if size
-          NewRelic::Agent.record_metric('Supportability/invoke_remote_size', size)
-          NewRelic::Agent.record_metric('Supportability/invoke_remote_size/' + method.to_s, size)
+          NewRelic::Agent.record_metric("Supportability/invoke_remote_size", size)
+          NewRelic::Agent.record_metric("Supportability/invoke_remote_size/#{method.to_s}", size)
         end
       end
 
@@ -353,7 +363,7 @@ module NewRelic
         when Net::HTTPSuccess
           true # fall through
         when Net::HTTPUnauthorized
-          raise LicenseException, 'Invalid license key, please contact support@newrelic.com'
+          raise LicenseException, 'Invalid license key, please visit support.newrelic.com'
         when Net::HTTPServiceUnavailable
           raise ServerConnectionException, "Service unavailable (#{response.code}): #{response.message}"
         when Net::HTTPGatewayTimeOut
@@ -416,7 +426,9 @@ module NewRelic
 
         module Base64CompressedJSON
           def self.encode(data)
-            Base64.encode64(Compressed.encode(JSON.dump(data)))
+            json = ::NewRelic::JSONWrapper.dump(data,
+              :normalize => Agent.config[:normalize_json_string_encodings])
+            Base64.encode64(Compressed.encode(json))
           end
         end
       end
@@ -424,9 +436,6 @@ module NewRelic
       # Used to wrap errors reported to agent by the collector
       class CollectorError < StandardError; end
 
-      # Used to wrap any problem with the JSON marshaller
-      class JsonError < StandardError; end
-
       class Marshaller
         def parsed_error(error)
           error_class = error['error_type'].split('::') \
@@ -511,14 +520,13 @@ module NewRelic
         end
 
         def dump(ruby, opts={})
-          JSON.dump(prepare(ruby, opts))
-        rescue => e
-          ::NewRelic::Agent.logger.debug "#{e.class.name} : #{e.message} encountered dumping agent data: #{ruby}"
-          raise JsonError.new(e)
+          prepared = prepare(ruby, opts)
+          NewRelic::JSONWrapper.dump(prepared,
+            :normalize => Agent.config[:normalize_json_string_encodings])
         end
 
         def load(data)
-          return_value(JSON.load(data)) if data && data != ''
+          return_value(NewRelic::JSONWrapper.load(data)) if data && data != ''
         rescue => e
           ::NewRelic::Agent.logger.debug "#{e.class.name} : #{e.message} encountered loading collector response: #{data}"
           raise
@@ -533,7 +541,7 @@ module NewRelic
         end
 
         def self.is_supported?
-          NewRelic::LanguageSupport.stdlib_json_usable?
+          NewRelic::JSONWrapper.usable_for_collector_serialization?
         end
 
         def self.human_readable?

data/lib/new_relic/agent/request_sampler.rb

@@ -12,9 +12,6 @@ class NewRelic::Agent::RequestSampler
   include NewRelic::Coerce,
           MonitorMixin
 
-  # The namespace and keys of config values
-  ENABLED_KEY                = :'analytics_events.enabled'
-
   # The type field of the sample
   SAMPLE_TYPE              = 'Transaction'
 
@@ -102,7 +99,7 @@ class NewRelic::Agent::RequestSampler
       self.reset!
     end
 
-    NewRelic::Agent.config.register_callback(ENABLED_KEY) do |enabled|
+    NewRelic::Agent.config.register_callback(:'analytics_events.enabled') do |enabled|
       NewRelic::Agent.logger.info "%sabling the Request Sampler." % [ enabled ? 'En' : 'Dis' ]
       @enabled = enabled
     end
@@ -117,20 +114,30 @@ class NewRelic::Agent::RequestSampler
   def on_transaction_finished(payload)
     return unless @enabled
     return unless NewRelic::Agent::Transaction.transaction_type_is_web?(payload[:type])
-    # The order in which these are merged is important.  We want to ensure that
-    # custom parameters can't override required fields (e.g. type)
-    sample = {}
-    if ::NewRelic::Agent.config[:'capture_attributes.transaction_events']
-      sample.merge!(event_params(payload[:custom_params] || {}))
-    end
-    sample.merge!(payload[:overview_metrics] || {})
+
+    main_event = create_main_event(payload)
+    custom_params = create_custom_parameters(payload)
+
+    is_full = self.synchronize { @samples.append([main_event, custom_params]) }
+    notify_full if is_full && !@notified_full
+  end
+
+  def create_main_event(payload)
+    sample = payload[:overview_metrics] || {}
     sample.merge!({
         TIMESTAMP_KEY     => float(payload[:start_timestamp]),
         NAME_KEY          => string(payload[:name]),
         DURATION_KEY      => float(payload[:duration]),
         TYPE_KEY          => SAMPLE_TYPE,
       })
-    is_full = self.synchronize { @samples.append(sample) }
-    notify_full if is_full && !@notified_full
   end
+
+  def create_custom_parameters(payload)
+    custom_params = {}
+    if ::NewRelic::Agent.config[:'analytics_events.capture_attributes']
+      custom_params.merge!(event_params(payload[:custom_params] || {}))
+    end
+    custom_params
+  end
+
 end

data/lib/new_relic/agent/sampler_collection.rb

@@ -16,6 +16,10 @@ module NewRelic
         @samplers.each(&blk)
       end
 
+      def clear()
+        @samplers.clear
+      end
+
       def sampler_class_registered?(sampler_class)
         self.any? { |s| s.class == sampler_class }
       end

data/lib/new_relic/agent/stats_engine/stats_hash.rb

@@ -38,9 +38,9 @@ module NewRelic
         Hash[self] == Hash[other]
       end
 
-      class CorruptedDefaultProcError < NewRelic::Agent::InternalAgentError
-        def initialize(hash, metric_spec)
-          super("Corrupted default proc for StatsHash. Falling back adding #{metric_spec.inspect}")
+      class StatsHashLookupError < NewRelic::Agent::InternalAgentError
+        def initialize(original_error, hash, metric_spec)
+          super("Lookup error in StatsHash: #{original_error.class}: #{original_error.message}. Falling back adding #{metric_spec.inspect}")
         end
       end
 
@@ -53,7 +53,7 @@ module NewRelic
             # This only happen in the case of a corrupted default_proc
             # Side-step it manually, notice the issue, and carry on....
             NewRelic::Agent.instance.error_collector. \
-              notice_agent_error(CorruptedDefaultProcError.new(self, metric_spec))
+              notice_agent_error(StatsHashLookupError.new(e, self, metric_spec))
 
             stats = NewRelic::Agent::Stats.new
             self[metric_spec] = stats

data/lib/new_relic/agent/system_info.rb

@@ -21,20 +21,8 @@ module NewRelic
         when /darwin/, /freebsd/
           `sysctl -n hw.ncpu`.to_i
         when /linux/
-          cpuinfo = ''
-          proc_file = '/proc/cpuinfo'
-          File.open(proc_file) do |f|
-            loop do
-              begin
-                cpuinfo << f.read_nonblock(4096).strip
-              rescue EOFError
-                break
-              rescue Errno::EWOULDBLOCK, Errno::EAGAIN
-                cpuinfo = ''
-                break # don't select file handle, just give up
-              end
-            end
-          end
+          cpuinfo = proc_try_read('/proc/cpuinfo')
+          return unless cpuinfo
           processors = cpuinfo.split("\n").select {|line| line =~ /^processor\s*:/ }.size
           processors == 0 ? nil : processors
         end
@@ -47,7 +35,29 @@ module NewRelic
       end
 
       def self.os_version
-        `uname -v` rescue nil
+        proc_try_read('/proc/version')
+      end
+
+      # A File.read against /(proc|sysfs)/* can hang with some older Linuxes.
+      # See https://bugzilla.redhat.com/show_bug.cgi?id=604887, RUBY-736, and
+      # https://github.com/opscode/ohai/commit/518d56a6cb7d021b47ed3d691ecf7fba7f74a6a7
+      # for details on why we do it this way.
+      def self.proc_try_read(path)
+        return nil unless File.exist?(path)
+        content = ''
+        File.open(path) do |f|
+          loop do
+            begin
+              content << f.read_nonblock(4096)
+            rescue EOFError
+              break
+            rescue Errno::EWOULDBLOCK, Errno::EAGAIN
+              content = nil
+              break # don't select file handle, just give up
+            end
+          end
+        end
+        content
       end
     end
   end

data/lib/new_relic/agent/transaction.rb

@@ -262,16 +262,35 @@ module NewRelic
       # Anything left over is treated as custom params
 
       def self.notice_error(e, options={})
+        options = extract_request_options(options)
+        if current
+          current.notice_error(e, options)
+        else
+          options = extract_finished_transaction_options(options)
+          agent.error_collector.notice_error(e, options)
+        end
+      end
+
+      def self.extract_request_options(options)
         request = options.delete(:request)
         if request
           options[:referer] = referer_from_request(request)
           options[:uri] = uri_from_request(request)
         end
-        if current
-          current.notice_error(e, options)
-        else
-          agent.error_collector.notice_error(e, options)
+        options
+      end
+
+      # If we aren't currently in a transaction, but found the remains of one
+      # just finished in the TransactionState, use those custom params!
+      def self.extract_finished_transaction_options(options)
+        finished_txn = NewRelic::Agent::TransactionState.get.transaction
+        if finished_txn
+          custom_params = options.fetch(:custom_params, {})
+          custom_params.merge!(finished_txn.custom_parameters)
+          options = options.merge(:custom_params => custom_params)
+          options[:metric] = finished_txn.name
         end
+        options
       end
 
       # Do not call this.  Invoke the class method instead.

data/lib/new_relic/agent/transaction_sampler.rb

@@ -93,7 +93,7 @@ module NewRelic
       end
 
       def custom_parameters_from_transaction(txn)
-        if Agent.config[:'capture_attributes.traces']
+        if Agent.config[:'transaction_tracer.capture_attributes']
           txn.custom_parameters
         else
           {}

data/lib/new_relic/cli/install.rb

@@ -57,7 +57,7 @@ you receive upon registration.
     EOF
     puts <<-EOF unless quiet
 
-E-mail support@newrelic.com with any problems or questions.
+Visit support.newrelic.com if you are experiencing installation issues.
     EOF
 
   end

data/lib/new_relic/control.rb

@@ -8,6 +8,7 @@ require 'conditional_vendored_dependency_detection'
 require 'new_relic/local_environment'
 require 'new_relic/language_support'
 require 'new_relic/helper'
+require 'new_relic/json_wrapper'
 
 require 'singleton'
 require 'erb'

data/lib/new_relic/helper.rb

@@ -10,7 +10,7 @@ module NewRelic
 
     # confirm a string is correctly encoded (in >= 1.9)
     # If not force the encoding to ASCII-8BIT (binary)
-    if RUBY_VERSION >= '1.9'
+    if NewRelic::LanguageSupport.supports_string_encodings?
       def correctly_encoded(string)
         return string unless string.is_a? String
         # The .dup here is intentional, since force_encoding mutates the target,
@@ -51,32 +51,4 @@ module NewRelic
       milliseconds / 1000.0
     end
   end
-
-  # Load the JSON library from the standard library.
-  def self::load_stdlib_json
-    return false unless NewRelic::LanguageSupport.stdlib_json_usable?
-
-    require 'json'
-    define_method( :json_dump, &::JSON.method(:dump) )
-    define_method( :json_load, &::JSON.method(:parse) )
-
-    return true
-  rescue LoadError
-    NewRelic::Agent.logger.debug "%p while loading JSON library: %s" % [ err, err.message ] if
-      defined?( NewRelic::Agent ) && NewRelic::Agent.respond_to?( :logger )
-    return false
-  end
-
-
-  # Load the fallback JSON library
-  def self::load_okjson
-    require 'new_relic/okjson'
-    define_method( :json_dump, &::NewRelic::OkJson.method(:encode) )
-    define_method( :json_load, &::NewRelic::OkJson.method(:decode) )
-  end
-
-
-  load_stdlib_json or load_okjson
-  module_function :json_dump, :json_load
-
 end

data/lib/new_relic/json_wrapper.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
+
+module NewRelic
+  class JSONWrapper
+    def self.load_stdlib_json
+      return false unless NewRelic::LanguageSupport.stdlib_json_usable?
+
+      begin
+        require 'json'
+        @load_method = ::JSON.method(:load)
+        @dump_method = ::JSON.method(:dump)
+        @backend_name = :json
+        return true
+      rescue
+        NewRelic::Agent.logger.debug "%p while loading JSON library: %s" % [ err, err.message ] if
+          defined?( NewRelic::Agent ) && NewRelic::Agent.respond_to?( :logger )
+      end
+    end
+
+    def self.load_okjson
+      require 'new_relic/okjson'
+      @load_method = ::NewRelic::OkJson.method(:decode)
+      @dump_method = ::NewRelic::OkJson.method(:encode)
+      @backend_name = :okjson
+    end
+
+    load_stdlib_json or load_okjson
+
+    def self.usable_for_collector_serialization?
+      @backend_name == :json
+    end
+
+    def self.normalize_string(s)
+      encoding = s.encoding
+      if (encoding == Encoding::UTF_8 || encoding == Encoding::ISO_8859_1) && s.valid_encoding?
+        return s
+      end
+
+      # If the encoding is not valid, or it's ASCII-8BIT, we know conversion to
+      # UTF-8 is likely to fail, so treat it as ISO-8859-1 (byte-preserving).
+      normalized = s.dup
+      if encoding == Encoding::ASCII_8BIT || !s.valid_encoding?
+        normalized.force_encoding(Encoding::ISO_8859_1)
+      else
+        # Encoding is valid and non-binary, so it might be cleanly convertible
+        # to UTF-8. Give it a try and fall back to ISO-8859-1 if it fails.
+        begin
+          normalized.encode!(Encoding::UTF_8)
+        rescue
+          normalized.force_encoding(Encoding::ISO_8859_1)
+        end
+      end
+      normalized
+    end
+
+    def self.normalize(object)
+      case object
+      when String
+        normalize_string(object)
+      when Array
+        return object if object.empty?
+        result = object.map { |x| normalize(x) }
+        result
+      when Hash
+        return object if object.empty?
+        hash = {}
+        object.each_pair do |k, v|
+          k = normalize_string(k) if k.is_a?(String)
+          hash[k] = normalize(v)
+        end
+        hash
+      else
+        object
+      end
+    end
+
+    def self.supports_normalization?
+      NewRelic::LanguageSupport.supports_string_encodings?
+    end
+
+    def self.dump(object, options={})
+      object = normalize(object) if options[:normalize]
+      @dump_method.call(object)
+    end
+
+    def self.load(string)
+      @load_method.call(string)
+    end
+  end
+end