newrelic_rpm 3.11.2.286 → 3.12.0.288

data/lib/new_relic/agent/transaction/attributes.rb

@@ -0,0 +1,161 @@
+# 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/attribute_processing'
+
+module NewRelic
+  module Agent
+    class Transaction
+      class Attributes
+        KEY_LIMIT   = 255
+        VALUE_LIMIT = 255
+        COUNT_LIMIT = 64
+
+        EMPTY_HASH = {}.freeze
+
+        CAN_BYTESLICE = String.instance_methods.include?(:byteslice)
+
+        def initialize(filter)
+          @filter = filter
+
+          @custom_attributes = {}
+          @agent_attributes = {}
+          @intrinsic_attributes = {}
+
+          @custom_destinations = {}
+          @agent_destinations = {}
+        end
+
+        def add_agent_attribute(key, value, default_destinations)
+          destinations = @filter.apply(key, default_destinations)
+          return if destinations == AttributeFilter::DST_NONE
+
+          @agent_destinations[key] = destinations
+          add(@agent_attributes, key, value)
+        end
+
+        def add_agent_attribute_with_key_check(key, value, default_destinations)
+          if exceeds_bytesize_limit? key, KEY_LIMIT
+            NewRelic::Agent.logger.debug("Agent attribute #{key} was dropped for exceeding key length limit #{KEY_LIMIT}")
+            return
+          end
+
+          add_agent_attribute(key, value, default_destinations)
+        end
+
+        def add_intrinsic_attribute(key, value)
+          add(@intrinsic_attributes, key, value)
+        end
+
+        def merge_untrusted_agent_attributes(attributes, prefix, default_destinations)
+          return if @filter.high_security?
+          return if !@filter.might_allow_prefix?(prefix)
+
+          AttributeProcessing.flatten_and_coerce(attributes, prefix) do |k, v|
+            add_agent_attribute_with_key_check(k, v, AttributeFilter::DST_NONE)
+          end
+        end
+
+        def merge_custom_attributes(other)
+          return if other.empty?
+          AttributeProcessing.flatten_and_coerce(other) do |k, v|
+            add_custom_attribute(k, v)
+          end
+        end
+
+        def custom_attributes_for(destination)
+          for_destination(@custom_attributes, @custom_destinations, destination)
+        end
+
+        def agent_attributes_for(destination)
+          for_destination(@agent_attributes, @agent_destinations, destination)
+        end
+
+        def intrinsic_attributes_for(destination)
+          if destination == NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER ||
+             destination == NewRelic::Agent::AttributeFilter::DST_ERROR_COLLECTOR
+            @intrinsic_attributes
+          else
+            EMPTY_HASH
+          end
+        end
+
+        private
+
+        def add_custom_attribute(key, value)
+          if @custom_attributes.size >= COUNT_LIMIT
+            unless @already_warned_count_limit
+              NewRelic::Agent.logger.warn("Custom attributes count exceeded limit of #{COUNT_LIMIT}. Any additional custom attributes during this transaction will be dropped.")
+              @already_warned_count_limit = true
+            end
+            return
+          end
+
+          if @filter.high_security?
+            NewRelic::Agent.logger.debug("Unable to add custom attribute #{key} while in high security mode.")
+            return
+          end
+
+          if exceeds_bytesize_limit?(key, KEY_LIMIT)
+            NewRelic::Agent.logger.warn("Custom attribute key '#{key}' was longer than limit of #{KEY_LIMIT} bytes. This attribute will be dropped.")
+            return
+          end
+
+          destinations = @filter.apply(key, AttributeFilter::DST_ALL)
+          return if destinations == AttributeFilter::DST_NONE
+
+          @custom_destinations[key] = destinations
+          add(@custom_attributes, key, value)
+        end
+
+        def add(attributes, key, value)
+          if exceeds_bytesize_limit?(value, VALUE_LIMIT)
+            value = slice(value)
+          end
+
+          attributes[key] = value
+        end
+
+        def for_destination(attributes, calculated_destinations, destination)
+          # Avoid allocating anything if there are no attrs at all
+          return EMPTY_HASH if attributes.empty?
+
+          return attributes.dup if destination == NewRelic::Agent::AttributeFilter::DST_DEVELOPER_MODE
+
+          attributes.inject({}) do |memo, (key, value)|
+            if @filter.allows?(calculated_destinations[key], destination)
+              memo[key] = value
+            end
+            memo
+          end
+        end
+
+        def exceeds_bytesize_limit?(value, limit)
+          if value.respond_to?(:bytesize)
+            value.bytesize > limit
+          elsif value.is_a?(Symbol)
+            value.to_s.bytesize > limit
+          else
+            false
+          end
+        end
+
+        # Take one byte past our limit. Why? This lets us unconditionally chop!
+        # the end. It'll either remove the one-character-too-many we have, or
+        # peel off the partial, mangled character left by the byteslice.
+        def slice(incoming)
+          if CAN_BYTESLICE
+            result = incoming.to_s.byteslice(0, VALUE_LIMIT + 1)
+          else
+            # < 1.9.3 doesn't have byteslice, so we take off bytes instead.
+            result = incoming.to_s.bytes.take(VALUE_LIMIT + 1).pack("C*")
+          end
+
+          result.chop!
+          result
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/transaction/developer_mode_sample_buffer.rb

@@ -39,14 +39,14 @@ module NewRelic
         def store_previous(*)
         end
 
-        # Captures the stack trace for a segment
+        # Captures the stack trace for a node
         # This is expensive and not for production mode
-        def visit_segment(segment)
-          return unless enabled? && segment
+        def visit_node(node)
+          return unless enabled? && node
 
           trace = strip_newrelic_frames(caller)
           trace = trace.first(40) if trace.length > 40
-          segment[:backtrace] = trace
+          node[:backtrace] = trace
         end
 
         def strip_newrelic_frames(trace)

data/lib/new_relic/agent/transaction/trace.rb

@@ -0,0 +1,150 @@
+# 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/transaction/trace_node'
+
+module NewRelic
+  module Agent
+    class Transaction
+      class Trace
+        class FinishedTraceError < StandardError; end
+
+        attr_reader :start_time, :root_node
+        attr_accessor :transaction_name, :uri, :guid, :xray_session_id,
+                      :attributes, :node_count, :finished, :threshold,
+                      :profile
+
+        def initialize(start_time)
+          @start_time = start_time
+          @node_count = 0
+          @root_node = NewRelic::Agent::Transaction::TraceNode.new(0.0, "ROOT")
+        end
+
+        def sample_id
+          self.object_id
+        end
+
+        def count_nodes
+          self.node_count
+        end
+
+        def duration
+          self.root_node.duration
+        end
+
+        def forced?
+          return true if NewRelic::Coerce.int_or_nil(xray_session_id)
+          false
+        end
+
+        def synthetics_resource_id
+          intrinsic_attributes = attributes.intrinsic_attributes_for(NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER)
+          intrinsic_attributes[:synthetics_resource_id]
+        end
+
+        def to_s_compact
+          @root_node.to_s_compact
+        end
+
+        def create_node(time_since_start, metric_name = nil)
+          raise FinishedTraceError.new "Can't create additional node for finished trace." if self.finished
+          self.node_count += 1
+          NewRelic::Agent::Transaction::TraceNode.new(time_since_start, metric_name)
+        end
+
+        def each_node(&block)
+          self.root_node.each_node(&block)
+        end
+
+        def prepare_to_send!
+          return self if @prepared
+
+          if NewRelic::Agent::Database.should_record_sql?
+            collect_explain_plans!
+            prepare_sql_for_transmission!
+          else
+            strip_sql!
+          end
+
+          @prepared = true
+          self
+        end
+
+        def collect_explain_plans!
+          return unless NewRelic::Agent::Database.should_collect_explain_plans?
+          threshold = NewRelic::Agent.config[:'transaction_tracer.explain_threshold']
+
+          each_node do |node|
+            if node[:sql] && node.duration > threshold
+              node[:explain_plan] = node.explain_sql
+            end
+          end
+        end
+
+        def prepare_sql_for_transmission!
+          strategy = NewRelic::Agent::Database.record_sql_method
+          each_node do |node|
+            next unless node[:sql]
+
+            case strategy
+            when :obfuscated
+              node[:sql] = NewRelic::Agent::Database.obfuscate_sql(node[:sql])
+            when :raw
+              node[:sql] = node[:sql].to_s
+            else
+              node[:sql] = nil
+            end
+          end
+        end
+
+        def strip_sql!
+          each_node do |node|
+            node.params.delete(:sql)
+          end
+        end
+
+        # Iterates recursively over each node in the entire transaction
+        # sample tree while keeping track of nested nodes
+        def each_node_with_nest_tracking(&block)
+          @root_node.each_node_with_nest_tracking(&block)
+        end
+
+        def trace_tree
+          destination = NewRelic::Agent::AttributeFilter::DST_TRANSACTION_TRACER
+
+          agent_attributes     = self.attributes.agent_attributes_for(destination)
+          custom_attributes    = self.attributes.custom_attributes_for(destination)
+          intrinsic_attributes = self.attributes.intrinsic_attributes_for(destination)
+
+          [
+            NewRelic::Coerce.float(self.start_time),
+            {},
+            {},
+            self.root_node.to_array,
+            {
+              'agentAttributes' => agent_attributes,
+              'userAttributes'  => custom_attributes,
+              'intrinsics'      => intrinsic_attributes
+            }
+          ]
+        end
+
+        def to_collector_array(encoder)
+          [
+            NewRelic::Helper.time_to_millis(self.start_time),
+            NewRelic::Helper.time_to_millis(self.root_node.duration),
+            NewRelic::Coerce.string(self.transaction_name),
+            NewRelic::Coerce.string(self.uri),
+            encoder.encode(trace_tree),
+            NewRelic::Coerce.string(self.guid),
+            nil,
+            forced?,
+            NewRelic::Coerce.int_or_nil(xray_session_id),
+            NewRelic::Coerce.string(self.synthetics_resource_id)
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/transaction/trace_node.rb

@@ -0,0 +1,190 @@
+# 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 Transaction
+      class TraceNode
+        attr_reader :entry_timestamp
+        # The exit timestamp will be relative except for the outermost sample which will
+        # have a timestamp.
+        attr_reader :exit_timestamp
+        attr_reader :parent_node
+
+        attr_accessor :metric_name
+
+        UNKNOWN_NODE_NAME = '<unknown>'.freeze
+
+        def initialize(timestamp, metric_name)
+          @entry_timestamp = timestamp
+          @metric_name     = metric_name || UNKNOWN_NODE_NAME
+        end
+
+        # sets the final timestamp on a node to indicate the exit
+        # point of the node
+        def end_trace(timestamp)
+          @exit_timestamp = timestamp
+        end
+
+        def add_called_node(s)
+          @called_nodes ||= []
+          @called_nodes << s
+          s.parent_node = self
+        end
+
+        def to_s
+          to_debug_str(0)
+        end
+
+        def to_array
+          [ NewRelic::Helper.time_to_millis(@entry_timestamp),
+            NewRelic::Helper.time_to_millis(@exit_timestamp),
+            NewRelic::Coerce.string(@metric_name),
+            (@params || {}) ] +
+            [ (@called_nodes ? @called_nodes.map{|s| s.to_array} : []) ]
+        end
+
+        def path_string
+          "#{metric_name}[#{called_nodes.collect {|node| node.path_string }.join('')}]"
+        end
+
+        def to_s_compact
+          str = ""
+          str << metric_name
+          if called_nodes.any?
+            str << "{#{called_nodes.map { | cs | cs.to_s_compact }.join(",")}}"
+          end
+          str
+        end
+
+        def to_debug_str(depth)
+          tab = "  " * depth
+          s = tab.clone
+          s << ">> #{'%3i ms' % (@entry_timestamp*1000)} [#{self.class.name.split("::").last}] #{metric_name} \n"
+          unless params.empty?
+            params.each do |k,v|
+              s << "#{tab}    -#{'%-16s' % k}: #{v.to_s[0..80]}\n"
+            end
+          end
+          called_nodes.each do |cs|
+            s << cs.to_debug_str(depth + 1)
+          end
+          s << tab + "<< "
+          s << case @exit_timestamp
+          when nil then ' n/a'
+          when Numeric then '%3i ms' % (@exit_timestamp*1000)
+          else @exit_timestamp.to_s
+          end
+          s << " #{metric_name}\n"
+        end
+
+        def called_nodes
+          @called_nodes || []
+        end
+
+        # return the total duration of this node
+        def duration
+          (@exit_timestamp - @entry_timestamp).to_f
+        end
+
+        # return the duration of this node without
+        # including the time in the called nodes
+        def exclusive_duration
+          d = duration
+
+          called_nodes.each do |node|
+            d -= node.duration
+          end
+          d
+        end
+
+        def count_nodes
+          count = 1
+          called_nodes.each { | node | count  += node.count_nodes }
+          count
+        end
+
+        def []=(key, value)
+          # only create a parameters field if a parameter is set; this will save
+          # bandwidth etc as most nodes have no parameters
+          params[key] = value
+        end
+
+        def [](key)
+          params[key]
+        end
+
+        def params
+          @params ||= {}
+        end
+
+        def params=(p)
+          @params = p
+        end
+
+        # call the provided block for this node and each
+        # of the called nodes
+        def each_node(&block)
+          block.call self
+
+          if @called_nodes
+            @called_nodes.each do |node|
+              node.each_node(&block)
+            end
+          end
+        end
+
+        # call the provided block for this node and each
+        # of the called nodes while keeping track of nested nodes
+        def each_node_with_nest_tracking(&block)
+          summary = block.call self
+          summary.current_nest_count += 1 if summary
+
+          if @called_nodes
+            @called_nodes.each do |node|
+              node.each_node_with_nest_tracking(&block)
+            end
+          end
+
+          summary.current_nest_count -= 1 if summary
+        end
+
+        # This is only for use by developer mode
+        def find_node(id)
+          return self if object_id == id
+          called_nodes.each do |node|
+            found = node.find_node(id)
+            return found if found
+          end
+          nil
+        end
+
+        def explain_sql
+          return params[:explain_plan] if params.key?(:explain_plan)
+
+          statement = params[:sql]
+          return nil unless statement.respond_to?(:config) &&
+            statement.respond_to?(:explainer)
+
+          NewRelic::Agent::Database.explain_sql(statement,
+                                                statement.config,
+                                                &statement.explainer)
+        end
+
+        def obfuscated_sql
+          NewRelic::Agent::Database.obfuscate_sql(params[:sql])
+        end
+
+        def called_nodes=(nodes)
+          @called_nodes = nodes
+        end
+
+        protected
+        def parent_node=(s)
+          @parent_node = s
+        end
+      end
+    end
+  end
+end