newrelic_rpm 3.9.1.236 → 3.9.2.239

data/lib/new_relic/agent/new_relic_service/encoders.rb

@@ -0,0 +1,34 @@
+# 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.
+
+require 'base64'
+require 'zlib'
+
+module NewRelic
+  module Agent
+    class NewRelicService
+      module Encoders
+        module Identity
+          def self.encode(data)
+            data
+          end
+        end
+
+        module Compressed
+          def self.encode(data)
+            Zlib::Deflate.deflate(data, Zlib::DEFAULT_COMPRESSION)
+          end
+        end
+
+        module Base64CompressedJSON
+          def self.encode(data)
+            json = ::NewRelic::JSONWrapper.dump(data,
+              :normalize => Agent.config[:normalize_json_string_encodings])
+            Base64.encode64(Compressed.encode(json))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/new_relic_service/json_marshaller.rb

@@ -0,0 +1,50 @@
+# 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.
+
+require 'new_relic/agent/new_relic_service/marshaller'
+
+module NewRelic
+  module Agent
+    class NewRelicService
+      # Marshal collector protocol with JSON when available
+      class JsonMarshaller < Marshaller
+        def initialize
+          ::NewRelic::Agent.logger.debug "Using JSON marshaller (#{NewRelic::JSONWrapper.backend_name})"
+          unless self.class.is_supported?
+            ::NewRelic::Agent.logger.warn "The JSON marshaller in use (#{NewRelic::JSONWrapper.backend_name}) is not recommended. Ensure the 'json' gem is available in your application for better performance."
+          end
+        end
+
+        def dump(ruby, opts={})
+          prepared = prepare(ruby, opts)
+          NewRelic::JSONWrapper.dump(prepared,
+            :normalize => Agent.config[:normalize_json_string_encodings])
+        end
+
+        def load(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
+        end
+
+        def default_encoder
+          Encoders::Base64CompressedJSON
+        end
+
+        def format
+          'json'
+        end
+
+        def self.is_supported?
+          NewRelic::JSONWrapper.usable_for_collector_serialization?
+        end
+
+        def self.human_readable?
+          true # for some definitions of 'human'
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/new_relic_service/marshaller.rb

@@ -0,0 +1,52 @@
+# 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
+  module Agent
+    class NewRelicService
+      class Marshaller
+        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
+
+        def prepare(data, options={})
+          encoder = options[:encoder] || default_encoder
+          if data.respond_to?(:to_collector_array)
+            data.to_collector_array(encoder)
+          elsif data.kind_of?(Array)
+            data.map { |element| prepare(element, options) }
+          else
+            data
+          end
+        end
+
+        def default_encoder
+          Encoders::Identity
+        end
+
+        def self.human_readable?
+          false
+        end
+
+        protected
+
+        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
+    end
+  end
+end

data/lib/new_relic/agent/new_relic_service/pruby_marshaller.rb

@@ -0,0 +1,52 @@
+# 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.
+
+require 'new_relic/agent/new_relic_service/marshaller'
+
+module NewRelic
+  module Agent
+    class NewRelicService
+      # Primitive Ruby Object Notation which complies JSON format data strutures
+      class PrubyMarshaller < Marshaller
+        def initialize
+          ::NewRelic::Agent.logger.debug 'Using Pruby marshaller'
+          warn_for_pruby_deprecation
+        end
+
+        def warn_for_pruby_deprecation
+          if RUBY_VERSION < "1.9" && !defined?(::JSON)
+            NewRelic::Agent.logger.warn("Upcoming versions of the Ruby agent running on Ruby 1.8.7 will require the 'json' gem. To avoid interuption in reporting, please update your Gemfile. See http://docs.newrelic.com/docs/ruby/ruby-1.8.7-support for more information.")
+          end
+        end
+
+        def dump(ruby, opts={})
+          NewRelic::LanguageSupport.with_cautious_gc do
+            Marshal.dump(prepare(ruby, opts))
+          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
+    end
+  end
+end

data/lib/new_relic/agent/threading/backtrace_node.rb

@@ -105,7 +105,7 @@ module NewRelic
         end
 
         def dump_string(indent=0)
-          file, method, line = parse_backtrace_frame(@raw_line)
+          @file, @method, @line_no = parse_backtrace_frame(@raw_line)
           result = "#{" " * indent}#<BacktraceNode:#{object_id} [#{@runnable_count}] #{@file}:#{@line_no} in #{@method}>"
           child_results = @children.map { |c| c.dump_string(indent+2) }.join("\n")
           result << "\n" unless child_results.empty?

data/lib/new_relic/agent/traced_method_stack.rb

@@ -45,8 +45,7 @@ module NewRelic
       #
       # +name+ will be applied to the generated transaction trace segment.
       def pop_frame(state, expected_frame, name, time, deduct_call_time_from_parent=true)
-        frame = @stack.pop
-        fail "unbalanced pop from blame stack, got #{frame ? frame.tag : 'nil'}, expected #{expected_frame ? expected_frame.tag : 'nil'}" if frame != expected_frame
+        frame = fetch_matching_frame(expected_frame)
 
         note_children_time(frame, time, deduct_call_time_from_parent)
 
@@ -55,6 +54,21 @@ module NewRelic
         frame
       end
 
+      def fetch_matching_frame(expected_frame)
+        while frame = @stack.pop
+          if frame == expected_frame
+            return frame
+          else
+            NewRelic::Agent.logger.info("Unexpected frame in traced method stack: #{frame.inspect} expected to be #{expected_frame.inspect}")
+            NewRelic::Agent.logger.debug do
+              ["Backtrace for unexpected frame: ", caller.join("\n")]
+            end
+          end
+        end
+
+        raise "Frame not found in blame stack: #{expected_frame.inspect}"
+      end
+
       def note_children_time(frame, time, deduct_call_time_from_parent)
         if !@stack.empty?
           if deduct_call_time_from_parent

data/lib/new_relic/agent/transaction.rb

@@ -317,10 +317,6 @@ module NewRelic
         @frozen_name ? true : false
       end
 
-      def ignored?
-        @ignore_this_transaction
-      end
-
       # Indicate that we are entering a measured controller action or task.
       # Make sure you unwind every push with a pop call.
       def start(state)

data/lib/new_relic/collection_helper.rb

@@ -40,7 +40,7 @@ module NewRelic
     if backtrace && !Agent.config[:disable_backtrace_cleanup]
       # this is for 1.9.1, where strings no longer have Enumerable
       backtrace = backtrace.split("\n") if String === backtrace
-      backtrace = backtrace.map &:to_s
+      backtrace = backtrace.map(&:to_s)
       backtrace = backtrace.reject do |line|
         line.include?(NewRelic::Control.newrelic_root) or
         line =~ /^newrelic_rpm\s/
@@ -55,7 +55,7 @@ module NewRelic
 
   # Convert any kind of object to a short string.
   def flatten(object)
-    s = case object
+    case object
       when nil then ''
       when object.instance_of?(String) then object
       when String then String.new(object)  # convert string subclasses to strings

data/lib/new_relic/control/frameworks/rails.rb

@@ -98,6 +98,9 @@ module NewRelic
               require 'new_relic/rack/developer_mode'
               rails_config.middleware.use NewRelic::Rack::DeveloperMode
               ::NewRelic::Agent.logger.info("New Relic Agent Developer Mode enabled.")
+              if env == "production"
+                ::NewRelic::Agent.logger.warn("***New Relic Developer Mode is not intended to be enabled in production environments! We highly recommend setting developer_mode: false for the production environment in your newrelic.yml.")
+              end
             rescue => e
               ::NewRelic::Agent.logger.warn("Error installing New Relic Developer Mode", e)
             end

data/lib/new_relic/control/instrumentation.rb

@@ -27,8 +27,12 @@ module NewRelic
       # if the agent is not running.
       def install_shim
         # Once we install instrumentation, you can't undo that by installing the shim.
-        raise "Cannot install the Agent shim after instrumentation has already been installed!" if @instrumented
-        NewRelic::Agent.agent = NewRelic::Agent::ShimAgent.instance
+        if @instrumented
+          NewRelic::Agent.logger.error "Cannot install the Agent shim after instrumentation has already been installed!"
+          NewRelic::Agent.logger.error caller.join("\n")
+        else
+          NewRelic::Agent.agent = NewRelic::Agent::ShimAgent.instance
+        end
       end
 
       # Add instrumentation.  Don't call this directly.  Use NewRelic::Agent#add_instrumentation.

data/lib/new_relic/json_wrapper.rb

@@ -4,16 +4,14 @@
 
 module NewRelic
   class JSONWrapper
-    def self.load_stdlib_json
-      return false unless NewRelic::LanguageSupport.stdlib_json_usable?
-
+    def self.load_native_json
       begin
-        require 'json'
+        require 'json' unless defined?(::JSON)
         @load_method = ::JSON.method(:load)
         @dump_method = ::JSON.method(:dump)
         @backend_name = :json
         return true
-      rescue
+      rescue StandardError, ScriptError
         NewRelic::Agent.logger.debug "%p while loading JSON library: %s" % [ err, err.message ] if
           defined?( NewRelic::Agent ) && NewRelic::Agent.respond_to?( :logger )
       end
@@ -26,38 +24,62 @@ module NewRelic
       @backend_name = :okjson
     end
 
-    load_stdlib_json or load_okjson
+    load_native_json or load_okjson
 
     def self.usable_for_collector_serialization?
       @backend_name == :json
     end
 
+    def self.backend_name
+      @backend_name
+    end
+
     def self.normalize_string(s)
-      # Early return if called on 1.8.x. In normal circumstances 1.8.x
-      # shouldn't call this--it does nothing for Ruby-marshalled formats-- but
-      # we use it in multiverse to make comparing data more consistent.
-      return s unless supports_normalization?
+      choose_normalizer unless @normalizer
+      @normalizer.normalize(s)
+    end
 
-      encoding = s.encoding
-      if (encoding == Encoding::UTF_8 || encoding == Encoding::ISO_8859_1) && s.valid_encoding?
-        return s
+    def self.choose_normalizer
+      if NewRelic::LanguageSupport.supports_string_encodings?
+        @normalizer = EncodingNormalizer
+      else
+        @normalizer = IconvNormalizer
       end
+    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
+    class EncodingNormalizer
+      def self.normalize(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
+    end
+
+    class IconvNormalizer
+      def self.normalize(s)
+        if @iconv.nil?
+          require 'iconv'
+          @iconv = Iconv.new('utf-8', 'iso-8859-1')
         end
+        @iconv.iconv(s)
       end
-      normalized
     end
 
     def self.normalize(object)

data/lib/new_relic/language_support.rb

@@ -107,10 +107,6 @@ module NewRelic::LanguageSupport
     numbers == ::RUBY_VERSION.split('.')[0, numbers.size]
   end
 
-  def stdlib_json_usable?
-    RUBY_VERSION >= '1.9.2'
-  end
-
   def supports_string_encodings?
     RUBY_VERSION >= '1.9.0'
   end

data/lib/new_relic/latest_changes.rb

@@ -30,8 +30,8 @@ EOS
 
       current_item = nil
       latest.each do |line|
-        if line.match /^\s*\*.*/
-          if line.match /\(#{patch_level}\)/
+        if line.match(/^\s*\*.*/)
+          if line.match(/\(#{patch_level}\)/)
             # Found a patch level item, so start tracking the lines!
             current_item = line
           else

data/lib/new_relic/rack/developer_mode.rb

@@ -105,7 +105,7 @@ module NewRelic
           @obfuscated_sql = @segment.obfuscated_sql
         end
 
-        headers, explanations = @segment.explain_sql
+        _headers, explanations = @segment.explain_sql
         if explanations
           @explanation = explanations
           if !@explanation.blank?
@@ -138,12 +138,13 @@ module NewRelic
         if view.is_a? Hash
           layout = false
           if view[:object]
+            # object *is* used here, as it is capture in the binding below
             object = view[:object]
           end
 
           if view[:collection]
-            return view[:collection].map do |object|
-              render({:partial => view[:partial], :object => object})
+            return view[:collection].map do |obj|
+              render({:partial => view[:partial], :object => obj})
             end.join(' ')
           end