newrelic_rpm 3.11.2.286 → 3.12.0.288

data/lib/new_relic/cli/commands/install.rb

@@ -32,9 +32,9 @@ class NewRelic::Cli::Install < NewRelic::Cli::Command
       end
     end
     @license_key ||= NO_LICENSE_KEY
-    @app_name ||= @leftover
+    @app_name ||= @leftover.join(" ")
+    @agent_version = NewRelic::VERSION::STRING
     raise CommandFailure.new("Application name required.", @options) unless @app_name && @app_name.size > 0
-    @generated_for_user ||= @user_string || ""
   end
 
   def run

data/lib/new_relic/coerce.rb

@@ -10,6 +10,8 @@ module NewRelic
   # to provide documentation of expected types on to_collector_array methods,
   # and to log failures if totally invalid data gets into outgoing data
   module Coerce
+    module_function
+
     def int(value, context=nil)
       Integer(value)
     rescue => error
@@ -42,36 +44,21 @@ module NewRelic
       ""
     end
 
-    # Convert a hash into a format acceptable to be included with Transaction
-    # event data.
-    #
-    # We accept a hash and will return a new hash where all of the keys
-    # have been converted to strings.  As values we only allow Strings,
-    # Floats, Integers. Symbols are also allowed but are converted to strings.
-    # Any values of other type (e.g. Hash, Array, any other class) are
-    # discarded. Their keys are also removed from the results hash.
-    def event_params(value, context=nil)
-      unless value.is_a? Hash
-        raise ArgumentError, "Expected Hash but got #{value.class}"
-      end
-      value.inject({}) do |memo, (key, val)|
-        case val
-        when String, Integer, TrueClass, FalseClass
-          memo[key.to_s] = val
-        when Float
-          if val.finite?
-            memo[key.to_s] = val
-          else
-            memo[key.to_s] = nil
-          end
-        when Symbol
-          memo[key.to_s] = val.to_s
+    def scalar(val)
+      case val
+      when String, Integer, TrueClass, FalseClass
+        val
+      when Float
+        if val.finite?
+          val
+        else
+          nil
         end
-        memo
+      when Symbol
+        val.to_s
+      else
+        "#<#{val.class.to_s}>"
       end
-    rescue => error
-      log_failure(value.class, 'valid event params', context, error)
-      {}
     end
 
     def log_failure(value, type, context, error)

data/lib/new_relic/json_wrapper.rb

@@ -2,6 +2,9 @@
 # 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/encoding_normalizer'
+require 'new_relic/agent/hash_extensions'
+
 module NewRelic
   class JSONWrapper
     def self.load_native_json
@@ -26,7 +29,7 @@ module NewRelic
         @load_method    = ::JSON.method(:load)
         @backend_name   = :json
         return true
-      rescue StandardError, ScriptError
+      rescue StandardError, ScriptError => err
         NewRelic::Agent.logger.debug "%p while loading JSON library: %s" % [ err, err.message ] if
           defined?( NewRelic::Agent ) && NewRelic::Agent.respond_to?( :logger )
       end
@@ -49,89 +52,27 @@ module NewRelic
       @backend_name
     end
 
-    def self.normalize_string(s)
-      choose_normalizer unless @normalizer
-      @normalizer.normalize(s)
-    end
-
-    def self.choose_normalizer
-      if NewRelic::LanguageSupport.supports_string_encodings?
-        @normalizer = EncodingNormalizer
-      else
-        @normalizer = IconvNormalizer
-      end
-    end
-
-    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
-    end
-
-    def self.normalize(object)
-      case object
-      when String
-        normalize_string(object)
-      when Symbol
-        normalize_string(object.to_s)
-      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)
-          k = normalize_string(k.to_s) if k.is_a?(Symbol)
-          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]
+      # okjson doesn't handle symbol keys, so we must stringify them before encoding
+      object = Agent::HashExtensions.stringify_keys_in_object(object) if backend_name == :okjson
       @dump_method.call(object)
     end
 
     def self.load(string)
       @load_method.call(string)
     end
+
+    def self.normalize_string(s)
+      NewRelic::Agent::StringNormalizer.normalize_string(s)
+    end
+
+    def self.normalize(o)
+      NewRelic::Agent::EncodingNormalizer.normalize_object(o)
+    end
   end
 end

data/lib/new_relic/noticed_error.rb

@@ -3,20 +3,23 @@
 # See https://github.com/newrelic/rpm/blob/master/LICENSE for complete details.
 
 require 'new_relic/helper'
+require 'new_relic/agent/attribute_filter'
 
 # This class encapsulates an error that was noticed by New Relic in a managed app.
 class NewRelic::NoticedError
   extend NewRelic::CollectionHelper
-  attr_accessor :path, :timestamp, :params, :message, :exception_class_name
+
+  attr_accessor :path, :timestamp, :message, :exception_class_name,
+                :request_uri, :file_name, :line_number, :stack_trace,
+                :attributes_from_notice_error, :attributes
+
   attr_reader   :exception_id, :is_internal
 
   STRIPPED_EXCEPTION_REPLACEMENT_MESSAGE = "Message removed by New Relic 'strip_exception_messages' setting"
 
-  def initialize(path, data, exception, timestamp = Time.now)
+  def initialize(path, exception, timestamp = Time.now)
     @exception_id = exception.object_id
     @path = path
-    @params = NewRelic::NoticedError.normalize_params(data)
-
     @exception_class_name = exception.is_a?(Exception) ? exception.class.name : 'Error'
 
     # It's critical that we not hold onto the exception class constant in this
@@ -83,6 +86,79 @@ class NewRelic::NoticedError
       string(path),
       string(message),
       string(exception_class_name),
-      params ]
+      build_params ]
+  end
+
+  USER_ATTRIBUTES = "userAttributes".freeze
+  AGENT_ATTRIBUTES = "agentAttributes".freeze
+  INTRINSIC_ATTRIBUTES = "intrinsics".freeze
+
+  EMPTY_HASH = {}.freeze
+
+  DESTINATION = NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR
+
+  def build_params
+    params = base_parameters
+    append_attributes(params, USER_ATTRIBUTES, merged_custom_attributes)
+    append_attributes(params, AGENT_ATTRIBUTES, build_agent_attributes)
+    append_attributes(params, INTRINSIC_ATTRIBUTES, build_intrinsic_attributes)
+    params
   end
+
+  def base_parameters
+    params = {}
+    params[:request_uri] = request_uri if request_uri
+    params[:file_name]   = file_name   if file_name
+    params[:line_number] = line_number if line_number
+    params[:stack_trace] = stack_trace if stack_trace
+    params
+  end
+
+  # We can get custom attributes from two sources--the transaction, which we
+  # hold in @attributes, or passed options to notice_error which show up in
+  # @attributes_from_notice_error. Both need filtering, so merge them together
+  # in our Attributes class for consistent handling
+  def merged_custom_attributes
+    merged_attributes = NewRelic::Agent::Transaction::Attributes.new(NewRelic::Agent.instance.attribute_filter)
+
+    merge_custom_attributes_from_transaction(merged_attributes)
+    merge_custom_attributes_from_notice_error(merged_attributes)
+
+    merged_attributes.custom_attributes_for(DESTINATION)
+  end
+
+  def merge_custom_attributes_from_transaction(merged_attributes)
+    if @attributes
+      from_transaction = @attributes.custom_attributes_for(DESTINATION)
+      merged_attributes.merge_custom_attributes(from_transaction)
+    end
+  end
+
+  def merge_custom_attributes_from_notice_error(merged_attributes)
+    if @attributes_from_notice_error
+      from_notice_error = NewRelic::NoticedError.normalize_params(@attributes_from_notice_error)
+      merged_attributes.merge_custom_attributes(from_notice_error)
+    end
+  end
+
+  def build_agent_attributes
+    if @attributes
+      @attributes.agent_attributes_for(DESTINATION)
+    else
+      EMPTY_HASH
+    end
+  end
+
+  def build_intrinsic_attributes
+    if @attributes
+      @attributes.intrinsic_attributes_for(DESTINATION)
+    else
+      EMPTY_HASH
+    end
+  end
+
+  def append_attributes(outgoing_params, outgoing_key, source_attributes)
+    outgoing_params[outgoing_key] = source_attributes || {}
+  end
+
 end

data/lib/new_relic/rack/browser_monitoring.rb

@@ -19,6 +19,15 @@ module NewRelic::Rack
     # examine in order to look for a RUM insertion point.
     SCAN_LIMIT = 50_000
 
+    CONTENT_TYPE        = 'Content-Type'.freeze
+    CONTENT_DISPOSITION = 'Content-Disposition'.freeze
+    ATTACHMENT          = 'attachment'.freeze
+    TEXT_HTML           = 'text/html'.freeze
+
+    BODY_START          = "<body".freeze
+    HEAD_START          = "<head".freeze
+    GT                  = ">".freeze
+
     def traced_call(env)
       result = @app.call(env)   # [status, headers, response]
 
@@ -50,11 +59,11 @@ module NewRelic::Rack
     end
 
     def is_html?(headers)
-      headers["Content-Type"] && headers["Content-Type"].include?("text/html")
+      headers[CONTENT_TYPE] && headers[CONTENT_TYPE].include?(TEXT_HTML)
     end
 
     def is_attachment?(headers)
-      headers['Content-Disposition'].to_s.include?('attachment')
+      headers[CONTENT_DISPOSITION] && headers[CONTENT_DISPOSITION].include?(ATTACHMENT)
     end
 
     def is_streaming?(env)
@@ -99,10 +108,6 @@ module NewRelic::Rack
         NewRelic::Agent.logger.debug(msg)
       end
 
-      if headers['Content-Length']
-        headers['Content-Length'] = calculate_content_length(source).to_s
-      end
-
       source
     rescue => e
       NewRelic::Agent.logger.debug "Skipping RUM instrumentation on exception.", e
@@ -124,7 +129,7 @@ module NewRelic::Rack
     end
 
     def find_body_start(beginning_of_source)
-      beginning_of_source.index("<body")
+      beginning_of_source.index(BODY_START)
     end
 
     def find_x_ua_compatible_position(beginning_of_source)
@@ -138,18 +143,8 @@ module NewRelic::Rack
     end
 
     def find_end_of_head_open(beginning_of_source)
-      head_open = beginning_of_source.index("<head")
-      beginning_of_source.index(">", head_open) + 1 if head_open
-    end
-
-    # String does not respond to 'bytesize' in 1.8.6. Fortunately String#length
-    # returns bytes rather than characters in 1.8.6 so we can use that instead.
-    def calculate_content_length(source)
-      if source.respond_to?(:bytesize)
-        source.bytesize
-      else
-        source.length
-      end
+      head_open = beginning_of_source.index(HEAD_START)
+      beginning_of_source.index(GT, head_open) + 1 if head_open
     end
   end
 end

data/lib/new_relic/rack/developer_mode.rb

@@ -1,8 +1,6 @@
 # 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 'rack'
 require 'rack/request'
 require 'rack/response'
 require 'rack/file'
@@ -13,14 +11,7 @@ require 'new_relic/metric_parser/metric_parser'
 require 'new_relic/rack/agent_middleware'
 require 'new_relic/agent/instrumentation/middleware_proxy'
 
-require 'new_relic/transaction_sample'
-require 'new_relic/transaction_analysis'
-
 module NewRelic
-  class TransactionSample
-    include TransactionAnalysis
-  end
-
   module Rack
     # This middleware provides the 'developer mode' feature of newrelic_rpm,
     # which allows you to see data about local web transactions in development
@@ -41,6 +32,7 @@ module NewRelic
       VIEW_PATH   = File.expand_path('../../../../ui/views/'  , __FILE__)
       HELPER_PATH = File.expand_path('../../../../ui/helpers/', __FILE__)
       require File.join(HELPER_PATH, 'developer_mode_helper.rb')
+      require 'new_relic/rack/developer_mode/segment_summary'
 
       include NewRelic::DeveloperModeHelper
 
@@ -213,8 +205,8 @@ module NewRelic
 
         return render(:sample_not_found) unless @sample
 
-        @request_params = @sample.params['request_params'] || {}
-        @custom_params = @sample.params['custom_params'] || {}
+        @request_params = request_attributes_for(@sample)
+        @custom_params = custom_attributes_for(@sample)
 
         controller_metric = @sample.transaction_name
 
@@ -222,7 +214,7 @@ module NewRelic
         @sample_controller_name = metric_parser.controller_name
         @sample_action_name = metric_parser.action_name
 
-        @sql_segments = @sample.sql_segments
+        @sql_segments = sql_segments(@sample)
         if params['d']
           @sql_segments.sort!{|a,b| b.duration <=> a.duration }
         end
@@ -235,7 +227,7 @@ module NewRelic
 
       def get_samples
         @samples = NewRelic::Agent.instance.transaction_sampler.dev_mode_sample_buffer.samples.select do |sample|
-          sample.params[:path] != nil
+          sample.transaction_name != nil
         end
 
         return @samples = @samples.sort_by(&:duration).reverse                   if params['h']
@@ -260,8 +252,70 @@ module NewRelic
         return unless @sample
 
         segment_id = params['segment'].to_i
-        @segment = @sample.find_segment(segment_id)
+        @segment = @sample.root_node.find_node(segment_id)
+      end
+
+      def custom_attributes_for(sample)
+        sample.attributes.custom_attributes_for(NewRelic::Agent::AttributeFilter::DST_DEVELOPER_MODE)
+      end
+
+      REQUEST_PARAMETERS_PREFIX = "request.parameters".freeze
+
+      def request_attributes_for(sample)
+        agent_attributes = sample.attributes.agent_attributes_for(NewRelic::Agent::AttributeFilter::DST_DEVELOPER_MODE)
+        agent_attributes.inject({}) do |memo, (key, value)|
+          memo[key] = value if key.to_s.start_with?(REQUEST_PARAMETERS_PREFIX)
+          memo
+        end
+      end
+
+      def breakdown_data(sample, limit = nil)
+        metric_hash = {}
+        sample.each_node_with_nest_tracking do |node|
+          unless node == sample.root_node
+            metric_name = node.metric_name
+            metric_hash[metric_name] ||= SegmentSummary.new(metric_name, sample)
+            metric_hash[metric_name] << node
+            metric_hash[metric_name]
+          end
+        end
+
+        data = metric_hash.values
+
+        data.sort! do |x,y|
+          y.exclusive_time <=> x.exclusive_time
+        end
+
+        if limit && data.length > limit
+          data = data[0..limit - 1]
+        end
+
+        # add one last node for the remaining time if any
+        remainder = sample.duration
+        data.each do |node|
+          remainder -= node.exclusive_time
+        end
+
+        if (remainder*1000).round > 0
+          remainder_summary = SegmentSummary.new('Remainder', sample)
+          remainder_summary.total_time = remainder_summary.exclusive_time = remainder
+          remainder_summary.call_count = 1
+          data << remainder_summary
+        end
+
+        data
       end
+
+      # return an array of sql statements executed by this transaction
+      # each element in the array contains [sql, parent_segment_metric_name, duration]
+      def sql_segments(sample, show_non_sql_segments = true)
+        segments = []
+        sample.each_node do |segment|
+          segments << segment if segment[:sql] || segment[:sql_obfuscated] || (show_non_sql_segments && segment[:key])
+        end
+        segments
+      end
+
     end
   end
 end