newrelic_rpm 4.8.0.341 → 5.0.0.342

data/lib/new_relic/agent/external.rb

@@ -53,6 +53,15 @@ module NewRelic
       #
       def process_request_metadata request_metadata
         NewRelic::Agent.record_api_supportability_metric(:process_request_metadata)
+
+        if NewRelic::Agent.config[:'distributed_tracing.enabled']
+          NewRelic::Agent.logger.log_once(
+            :warn,
+            :process_request_metadata_noop,
+            'Skipping process_request_metadata because distributed tracing is enabled')
+          return
+        end
+
         return unless CrossAppTracing.cross_app_enabled?
 
         state = NewRelic::Agent::TransactionState.tl_get
@@ -100,6 +109,11 @@ module NewRelic
         NewRelic::Agent.record_api_supportability_metric(:get_response_metadata)
         return unless CrossAppTracing.cross_app_enabled?
 
+        if NewRelic::Agent.config[:'distributed_tracing.enabled']
+          ::NewRelic::Agent.logger.warn('Skipping get_response_metadata because distributed tracing is enabled')
+          return
+        end
+
         state = NewRelic::Agent::TransactionState.tl_get
         if transaction = state.current_transaction and state.client_cross_app_id
 

data/lib/new_relic/agent/heap.rb

@@ -0,0 +1,140 @@
+# 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
+    # This class implements a min Heap. The first element is always the one with the
+    # lowest priority. It is a tree structure that is represented as an array. The
+    # relationship between between nodes in the tree and indices in the array are as
+    # follows:
+    #
+    # parent_index      = (child_index -  1) / 2
+    # left_child_index  = parent_index * 2 + 1
+    # right_child_index = parent_index * 2 + 2
+    #
+    # the root node is at index 0
+    # a node is a leaf node when its index >= length / 2
+    #
+
+    class Heap
+
+      # @param [Array] items an optional array of items to intialize the heap
+      #
+      # @param [Callable] priority_fn an optional priority function used to
+      #   to compute the priority for an item. If it's not supplied priority
+      #   will be computed using Comparable.
+      def initialize(items = nil, &priority_fn)
+        @items = []
+        @priority_fn = priority_fn || ->(x) { x }
+        items.each{ |item| push(item) } if items
+      end
+
+      def [](index)
+        @items[index]
+      end
+
+      def []=(index, value)
+        @items[index] = value
+      end
+
+      def fix(index)
+        parent_index = parent_index_for(index)
+
+        if in_range?(parent_index) && priority(parent_index) > priority(index)
+          heapify_up(index)
+        else
+          child_index = left_child_index_for(index)
+
+          return unless in_range?(child_index)
+
+          if right_sibling_smaller?(child_index)
+            child_index += 1
+          end
+
+          if priority(child_index) < priority(index)
+            heapify_down(index)
+          end
+        end
+      end
+
+      def push(item)
+        @items << item
+        heapify_up(size - 1)
+      end
+
+      alias_method :<<, :push
+
+      def pop
+        swap(0, size - 1)
+        item = @items.pop
+        heapify_down(0)
+        item
+      end
+
+      def size
+        @items.size
+      end
+
+      def empty?
+        @items.empty?
+      end
+
+      def to_a
+        @items
+      end
+
+      private
+
+      def priority(index)
+        @priority_fn.call(@items[index])
+      end
+
+      def parent_index_for child_index
+        (child_index - 1) / 2
+      end
+
+      def left_child_index_for parent_index
+        2 * parent_index + 1
+      end
+
+      def right_sibling_smaller?(lchild_index)
+        in_range?(lchild_index + 1) && priority(lchild_index) > priority(lchild_index + 1)
+      end
+
+      def in_range?(index)
+        index >= 0 && index < size
+      end
+
+      def heapify_up(child_index)
+        return if child_index == 0
+
+        parent_index = parent_index_for(child_index)
+
+        if priority(child_index) < priority(parent_index)
+          swap(child_index, parent_index)
+          heapify_up(parent_index)
+        end
+      end
+
+      def heapify_down(parent_index)
+        child_index = left_child_index_for(parent_index)
+        return unless in_range?(child_index)
+
+        if right_sibling_smaller?(child_index)
+          child_index += 1
+        end
+
+        if priority(child_index) < priority(parent_index)
+          swap(parent_index, child_index)
+          heapify_down(child_index)
+        end
+      end
+
+      def swap(i, j)
+        @items[i], @items[j] = @items[j], @items[i]
+      end
+    end
+
+  end
+end

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

@@ -24,7 +24,11 @@ DependencyDetection.defer do
         def publish payload, opts = {}
           begin
             destination = NewRelic::Agent::Instrumentation::Bunny.exchange_name(name)
-            opts[:headers] ||= {} if NewRelic::Agent::CrossAppTracing.cross_app_enabled?
+
+            tracing_enabled =
+              NewRelic::Agent::CrossAppTracing.cross_app_enabled? ||
+              NewRelic::Agent.config[:'distributed_tracing.enabled']
+            opts[:headers] ||= {} if tracing_enabled
 
             segment = NewRelic::Agent::Messaging.start_amqp_publish_segment(
               library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,

data/lib/new_relic/agent/instrumentation/rails5/action_cable.rb

@@ -27,6 +27,10 @@ DependencyDetection.defer do
     ActiveSupport::Notifications.subscribe(/(perform_action|transmit)\.action_cable/,
       NewRelic::Agent::Instrumentation::ActionCableSubscriber.new)
 
-    ::NewRelic::Agent::PrependSupportability.record_metrics_for(::ActionCable::Engine, ::ActionCable::RemoteConnections)
+    ActiveSupport.on_load(:action_cable) do
+      ::NewRelic::Agent::PrependSupportability.record_metrics_for(
+        ::ActionCable::Engine,
+        ::ActionCable::RemoteConnections)
+    end
   end
 end

data/lib/new_relic/agent/messaging.rb

@@ -364,7 +364,17 @@ module NewRelic
         transaction_name
       end
 
+      NEWRELIC_TRACE_KEY      = "NewRelicTrace".freeze
+      RABBITMQ_TRANSPORT_TYPE = "RabbitMQ".freeze
+
       def consume_message_headers headers, transaction, state
+        if Agent.config[:'distributed_tracing.enabled']
+          payload = headers[NEWRELIC_TRACE_KEY]
+          if transaction.accept_distributed_trace_payload payload
+            transaction.distributed_trace_payload.caller_transport_type = RABBITMQ_TRANSPORT_TYPE
+          end
+        end
+
         if CrossAppTracing.cross_app_enabled? && CrossAppTracing.message_has_crossapp_request_header?(headers)
           decode_id headers[CrossAppTracing::NR_MESSAGE_BROKER_ID_HEADER], state
           decode_txn_info headers[CrossAppTracing::NR_MESSAGE_BROKER_TXN_HEADER], state

data/lib/new_relic/agent/new_relic_service.rb

@@ -15,7 +15,8 @@ module NewRelic
       # Specifies the version of the agent's communication protocol with
       # the NewRelic hosted site.
 
-      PROTOCOL_VERSION = 14
+      PROTOCOL_VERSION = 15
+
       # 1f147a42: v10 (tag 3.5.3.17)
       # cf0d1ff1: v9 (tag 3.5.0)
       # 14105: v8 (tag 2.10.3)
@@ -30,8 +31,8 @@ module NewRelic
       # underlying TCP connection may be in a bad state.
       CONNECTION_ERRORS = [Timeout::Error, EOFError, SystemCallError, SocketError].freeze
 
-      attr_accessor :request_timeout, :agent_id
-      attr_reader :collector, :marshaller
+      attr_accessor :request_timeout
+      attr_reader :collector, :marshaller, :agent_id
 
       def initialize(license_key=nil, collector=control.server)
         @license_key = license_key
@@ -41,18 +42,12 @@ module NewRelic
         @in_session = nil
         @agent_id = nil
         @shared_tcp_connection = nil
+        reset_remote_method_uris
 
         @audit_logger = ::NewRelic::Agent::AuditLogger.new
         Agent.config.register_callback(:'audit_log.enabled') do |enabled|
           @audit_logger.enabled = enabled
         end
-        Agent.config.register_callback(:ssl) do |ssl|
-          if !ssl
-            ::NewRelic::Agent.logger.warn("Agent is configured not to use SSL when communicating with New Relic's servers")
-          else
-            ::NewRelic::Agent.logger.debug("Agent is configured to use SSL")
-          end
-        end
 
         Agent.config.register_callback(:marshaller) do |marshaller|
           if marshaller != 'json'
@@ -63,17 +58,26 @@ module NewRelic
         end
       end
 
+      def agent_id=(id)
+        # Remote URIs have the agent run ID in them, so we need to
+        # clear out our cached values whenever the run ID changes.
+        #
+        reset_remote_method_uris
+
+        @agent_id = id
+      end
+
       def connect(settings={})
-        if host = get_redirect_host
+        if host = preconnect
           @collector = NewRelic::Control.instance.server_from_host(host)
         end
         response = invoke_remote(:connect, [settings])
-        @agent_id = response['agent_run_id']
+        self.agent_id = response['agent_run_id']
         response
       end
 
-      def get_redirect_host
-        invoke_remote(:get_redirect_host)
+      def preconnect
+        invoke_remote(:preconnect)
       end
 
       def shutdown(time)
@@ -261,8 +265,7 @@ module NewRelic
         conn.verify_mode = OpenSSL::SSL::VERIFY_PEER
         conn.cert_store  = ssl_cert_store
       rescue StandardError, LoadError
-        msg = "Agent is configured to use SSL, but SSL is not available in the environment. "
-        msg << "Either disable SSL in the agent configuration, or install SSL support."
+        msg = "SSL is not available in the environment; please install SSL support."
         raise UnrecoverableAgentException.new(msg)
       end
 
@@ -296,7 +299,7 @@ module NewRelic
           conn = Net::HTTP.new(@collector.name, @collector.port)
         end
 
-        setup_connection_for_ssl(conn) if Agent.config[:ssl]
+        setup_connection_for_ssl(conn)
         setup_connection_timeouts(conn)
 
         ::NewRelic::Agent.logger.debug("Created net/http handle to #{conn.address}:#{conn.port}")
@@ -335,11 +338,28 @@ module NewRelic
         NewRelic::Control.instance
       end
 
-      # The path on the server that we should post our data to
-      def remote_method_uri(method, format)
-        params = {'run_id' => @agent_id, 'marshal_format' => format}
-        uri = "/agent_listener/#{PROTOCOL_VERSION}/#{license_key}/#{method}"
-        uri << '?' + params.map do |k,v|
+      def remote_method_uri(method)
+        @remote_method_uris[method]
+      end
+
+      def reset_remote_method_uris
+        @remote_method_uris = Hash.new do |hash, remote_method|
+          hash[remote_method] = generate_remote_method_uri(remote_method)
+        end
+      end
+
+      def generate_remote_method_uri(method)
+        params = {
+          'protocol_version' => PROTOCOL_VERSION,
+          'license_key'      => license_key,
+          'run_id'           => @agent_id,
+          'method'           => method,
+          'marshal_format'   => 'json', # Other formats are explicitly
+                                        # ruled out; see the initializer
+        }
+
+        uri = "/agent_listener/invoke_raw_method?"
+        uri << params.map do |k,v|
           next unless v
           "#{k}=#{v}"
         end.compact.join('&')
@@ -368,7 +388,7 @@ module NewRelic
         data, encoding = compress_request_if_needed(data)
         size = data.size
 
-        uri = remote_method_uri(method, @marshaller.format)
+        uri = remote_method_uri(method)
         full_uri = "#{@collector}#{uri}"
 
         @audit_logger.log_request(full_uri, payload, @marshaller)

data/lib/new_relic/agent/priority_sampled_buffer.rb

@@ -0,0 +1,68 @@
+# 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/heap'
+
+module NewRelic
+  module Agent
+    class PrioritySampledBuffer < SampledBuffer
+      PRIORITY_KEY = "priority".freeze
+
+      attr_reader :seen_lifetime, :captured_lifetime
+
+      def initialize(capacity)
+        super
+        @captured_lifetime = 0
+        @seen_lifetime     = 0
+      end
+
+      # expects priority and a block, or an event as a hash with a `priority` key.
+      def append(priority: nil, event: nil, &blk)
+        increment_seen
+
+        if @seen == @capacity
+          @items = Heap.new(@items) { |x| priority_for(x) }
+        end
+
+        if full?
+          priority ||= priority_for(event)
+          if priority_for(@items[0]) < priority
+            @items[0] = event || blk.call
+            @items.fix(0)
+          end
+        else
+          @items << (event || blk.call)
+          @captured_lifetime += 1
+        end
+      end
+
+      alias_method :append_event, :append
+
+      def capacity=(new_capacity)
+        @capacity = new_capacity
+        old_items = @items.to_a
+        old_seen  = @seen
+        reset!
+        old_items.each { |i| append(event: i) }
+        @seen     = old_seen
+      end
+
+      def to_a
+        @items.to_a.dup
+      end
+
+      private
+
+      def increment_seen
+        @seen += 1
+        @seen_lifetime += 1
+      end
+
+      def priority_for(event)
+        event[0][PRIORITY_KEY]
+      end
+    end
+  end
+end
+

data/lib/new_relic/agent/supported_versions.rb

@@ -11,7 +11,7 @@ module NewRelic
       {
         :type        => :ruby,
         :name        => "MRI",
-        :supported   => ["2.0.0", "~>2.1.0", "~>2.2.0", "~>2.3.0", "~>2.4.0"],
+        :supported   => ["2.0.0", "~>2.1.0", "~>2.2.0", "~>2.3.0", "~>2.4.0", "~>2.5.0"],
         :deprecated  => ["1.8.6", "1.8.7", "1.9.2", "1.9.3"],
         :url         => "https://www.ruby-lang.org",
         :feed        => "https://www.ruby-lang.org/en/feeds/news.rss",

data/lib/new_relic/agent/transaction.rb

@@ -58,7 +58,8 @@ module NewRelic
                     :http_response_code,
                     :response_content_length,
                     :response_content_type,
-                    :sampled
+                    :sampled,
+                    :priority
 
       attr_reader :guid,
                   :metrics,
@@ -283,11 +284,15 @@ module NewRelic
         @ignore_trace = false
 
         if Agent.config[:'distributed_tracing.enabled']
-          @sampled = NewRelic::Agent.instance.throughput_monitor.sampled?
+          @sampled = NewRelic::Agent.instance.adaptive_sampler.sampled?
         else
           @sampled = nil
         end
 
+        # we will eventually add this behavior into the AdaptiveSampler (ThroughputMontor)
+        @priority = rand
+        @priority +=1 if @sampled
+
         @attributes = Attributes.new(NewRelic::Agent.instance.attribute_filter)
 
         merge_request_parameters(@filtered_params)
@@ -596,7 +601,7 @@ module NewRelic
       end
 
       def assign_intrinsics(state)
-        attributes.add_intrinsic_attribute :'nr.sampled', sampled?
+        attributes.add_intrinsic_attribute :'sampled', sampled?
 
         if gc_time = calculate_gc_time
           attributes.add_intrinsic_attribute(:gc_time, gc_time)
@@ -612,8 +617,8 @@ module NewRelic
           attributes.add_intrinsic_attribute(:synthetics_monitor_id, synthetics_monitor_id)
         end
 
-        if distributed_trace_payload || order > 0
-          assign_distributed_tracing_intrinsics
+        if distributed_trace_payload || distributed_trace_payload_created?
+          assign_distributed_trace_intrinsics
         elsif state.is_cross_app?
           attributes.add_intrinsic_attribute(:trip_id, cat_trip_id)
           attributes.add_intrinsic_attribute(:path_hash, cat_path_hash)
@@ -648,13 +653,14 @@ module NewRelic
           :duration             => duration,
           :metrics              => @metrics,
           :attributes           => @attributes,
-          :error                => false
+          :error                => false,
+          :priority             => @priority
         }
 
-        @payload[:'nr.sampled'] = sampled? if Agent.config[:'distributed_tracing.enabled']
+        @payload[:'sampled'] = sampled? if Agent.config[:'distributed_tracing.enabled']
 
         append_cat_info(state, duration, @payload)
-        append_distributed_tracing_info(@payload)
+        append_distributed_trace_info(@payload)
         append_apdex_perf_zone(duration, @payload)
         append_synthetics_to(state, @payload)
         append_referring_transaction_guid_to(state, @payload)