newrelic_rpm 4.8.0.341 → 6.13.1

data/lib/new_relic/agent/error_event_aggregator.rb

@@ -1,25 +1,32 @@
 # -*- ruby -*-
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+# frozen_string_literal: true
 
 require 'new_relic/agent/event_aggregator'
 require 'new_relic/agent/transaction_error_primitive'
+require 'new_relic/agent/priority_sampled_buffer'
 
 module NewRelic
   module Agent
     class ErrorEventAggregator < EventAggregator
+      include NewRelic::Coerce
 
       named :ErrorEventAggregator
       capacity_key :'error_collector.max_event_samples_stored'
-      enabled_key :'error_collector.capture_events'
+      enabled_keys :'error_collector.enabled',
+                   :'error_collector.capture_events'
+      buffer_class PrioritySampledBuffer
 
-      def append_event noticed_error, transaction_payload = nil
+      def record noticed_error, transaction_payload = nil, span_id = nil
         return unless enabled?
 
+        priority = float!((transaction_payload && transaction_payload[:priority]) || rand)
+
         @lock.synchronize do
-          @buffer.append do
-            create_event(noticed_error, transaction_payload)
+          @buffer.append(priority: priority) do
+            create_event(noticed_error, transaction_payload, span_id)
           end
           notify_if_full
         end
@@ -27,8 +34,8 @@ module NewRelic
 
       private
 
-      def create_event noticed_error, transaction_payload
-        TransactionErrorPrimitive.create noticed_error, transaction_payload
+      def create_event noticed_error, transaction_payload, span_id
+        TransactionErrorPrimitive.create noticed_error, transaction_payload, span_id
       end
     end
   end

data/lib/new_relic/agent/error_trace_aggregator.rb

@@ -1,7 +1,7 @@
 # -*- ruby -*-
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 module NewRelic
   module Agent
@@ -91,6 +91,7 @@ module NewRelic
 
       def register_config_callbacks
         Agent.config.register_callback(:'error_collector.enabled') do |enabled|
+          reset! if enabled == false
           ::NewRelic::Agent.logger.debug "Error traces will #{enabled ? '' : 'not '}be sent to the New Relic service."
         end
       end

data/lib/new_relic/agent/event_aggregator.rb

@@ -1,8 +1,8 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
-require 'new_relic/agent/sampled_buffer'
+require 'new_relic/agent/priority_sampled_buffer'
 
 module NewRelic
   module Agent
@@ -16,26 +16,45 @@ module NewRelic
           key ? @capacity_key = key : @capacity_key
         end
 
-        def enabled_key key = nil
-          key ? @enabled_key = key : @enabled_key
+        # An aggregator can specify one or more keys to check to see if it is
+        # enabled. Multiple keys will be &&'d and the enabled status of the
+        # aggregator will be reset when agent configuration changes.
+
+        def enabled_keys *keys
+          if keys.empty?
+            @enabled_keys ||= []
+          else
+            @enabled_keys = Array(keys)
+            @enabled_fn = ->(){ @enabled_keys.all? { |k| Agent.config[k] } }
+          end
+        end
+
+        alias_method :enabled_key, :enabled_keys
+
+        # This can be used instead of `enabled_key(s)` for more fine grained
+        # control over whether an aggregator should be enabled. The enabled fn
+        # will be reevaluated after configuration changes
+
+        def enabled_fn fn = nil
+          fn ? @enabled_fn = fn : @enabled_fn
         end
 
         def buffer_class klass = nil
           if klass
             @buffer_class = klass
           else
-            @buffer_class ||= SampledBuffer
+            @buffer_class ||= PrioritySampledBuffer
           end
         end
       end
 
-      def initialize
+      def initialize events
         @lock = Mutex.new
         @buffer = self.class.buffer_class.new NewRelic::Agent.config[self.class.capacity_key]
-        @enabled = false
+        @enabled = self.class.enabled_fn ? self.class.enabled_fn.call : false
         @notified_full = false
         register_capacity_callback
-        register_enabled_callback
+        register_enabled_callback events
         after_initialize
       end
 
@@ -79,7 +98,7 @@ module NewRelic
             @buffer.decrement_lifetime_counts_by samples.count
           end
 
-          samples.each { |s| @buffer.append s }
+          samples.each { |s| @buffer.append event: s }
         end
       end
 
@@ -107,12 +126,12 @@ module NewRelic
         end
       end
 
-      def register_enabled_callback
-        NewRelic::Agent.config.register_callback(self.class.enabled_key) do |enabled|
-          # intentionally unsynchronized for liveness
-          @enabled = enabled
-          ::NewRelic::Agent.logger.debug "#{self.class.named} will #{enabled ? '' : 'not '}be sent to the New Relic service."
-        end
+      def register_enabled_callback events
+        events.subscribe(:server_source_configuration_added) {
+          @enabled = self.class.enabled_fn.call
+          reset! if @enabled == false
+          ::NewRelic::Agent.logger.debug "#{self.class.named} will #{@enabled ? '' : 'not '}be sent to the New Relic service."
+        }
       end
 
       def notify_if_full

data/lib/new_relic/agent/event_buffer.rb

@@ -1,6 +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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 # EventBuffer is intended to be an abstract base class. It should not be
 # instantiated directly. Subclasses should define an `append_event` method

data/lib/new_relic/agent/event_listener.rb

@@ -1,6 +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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 module NewRelic::Agent
   # Basic mechanism for the agent instance to provide agent-wide eventing.

data/lib/new_relic/agent/event_loop.rb

@@ -1,6 +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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 require 'thread'
 

data/lib/new_relic/agent/external.rb

@@ -1,12 +1,20 @@
 # 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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 require 'new_relic/agent/transaction/tracing'
-require 'new_relic/agent/cross_app_tracing'
+require 'new_relic/agent/distributed_tracing/cross_app_tracing'
+require 'new_relic/agent/distributed_tracing/cross_app_payload'
 
 module NewRelic
   module Agent
+    #
+    # This module contains helper methods to facilitate
+    # instrumentation of external requests not directly supported by
+    # the Ruby agent. It is intended to be primarily used by authors
+    # of 3rd-party instrumentation.
+    #
+    # @api public
     module External
       extend self
 
@@ -26,13 +34,16 @@ module NewRelic
       #
       # @api public
       def start_segment(library: nil, uri: nil, procedure: nil)
+        Deprecator.deprecate 'External.start_segment',
+                             'Tracer#start_external_request_segment'
+
         raise ArgumentError, 'Argument `library` is required' if library.nil?
         raise ArgumentError, 'Argument `uri` is required' if uri.nil?
         raise ArgumentError, 'Argument `procedure` is required' if procedure.nil?
 
         ::NewRelic::Agent.record_api_supportability_metric(:start_segment)
 
-        ::NewRelic::Agent::Transaction.start_external_request_segment(
+        ::NewRelic::Agent::Tracer.start_external_request_segment(
           library: library,
           uri: uri,
           procedure: procedure
@@ -42,6 +53,7 @@ module NewRelic
       NON_HTTP_CAT_ID_HEADER  = 'NewRelicID'.freeze
       NON_HTTP_CAT_TXN_HEADER = 'NewRelicTransaction'.freeze
       NON_HTTP_CAT_SYNTHETICS_HEADER = 'NewRelicSynthetics'.freeze
+      NON_HTTP_CAT_CONTENT_LENGTH = -1
 
       # Process obfuscated +String+ indentifying a calling application and transaction that is also running a
       # New Relic agent and save information in current transaction for inclusion in a trace. The +String+ is
@@ -55,19 +67,19 @@ module NewRelic
         NewRelic::Agent.record_api_supportability_metric(:process_request_metadata)
         return unless CrossAppTracing.cross_app_enabled?
 
-        state = NewRelic::Agent::TransactionState.tl_get
+        state = NewRelic::Agent::Tracer.state
         if transaction = state.current_transaction
           rmd = ::JSON.parse obfuscator.deobfuscate(request_metadata)
 
           # handle/check ID
           #
           if id = rmd[NON_HTTP_CAT_ID_HEADER] and CrossAppTracing.trusted_valid_cross_app_id?(id)
-            state.client_cross_app_id = id
-
             # handle transaction info
             #
             if txn_info = rmd[NON_HTTP_CAT_TXN_HEADER]
-              state.referring_transaction_info = txn_info
+              payload = CrossAppPayload.new(id, transaction, txn_info)
+              transaction.distributed_tracer.cross_app_payload = payload
+
               CrossAppTracing.assign_intrinsic_transaction_attributes state
             end
 
@@ -100,31 +112,21 @@ module NewRelic
         NewRelic::Agent.record_api_supportability_metric(:get_response_metadata)
         return unless CrossAppTracing.cross_app_enabled?
 
-        state = NewRelic::Agent::TransactionState.tl_get
-        if transaction = state.current_transaction and state.client_cross_app_id
+        return unless (txn = Tracer.current_transaction)
+        return unless (payload = txn.distributed_tracer.cross_app_payload)
 
-          # must freeze the name since we're responding with it
+        # must freeze the name since we're responding with it
+        #
+        txn.freeze_name_and_execute_if_not_ignored do
+          # build response payload
           #
-          transaction.freeze_name_and_execute_if_not_ignored do
-
-            # build response payload
-            #
-            rmd = {
-              NewRelicAppData: [
-                NewRelic::Agent.config[:cross_process_id],
-                state.timings.transaction_name,
-                state.timings.queue_time_in_seconds.to_f,
-                state.timings.app_time_in_seconds.to_f,
-                -1, # per non-HTTP CAT spec
-                state.request_guid
-              ]
-            }
-
-            # obfuscate the generated response metadata JSON
-            #
-            obfuscator.obfuscate ::JSON.dump(rmd)
+          rmd = {
+            NewRelicAppData: payload.as_json_array(NON_HTTP_CAT_CONTENT_LENGTH)
+          }
 
-          end
+          # obfuscate the generated response metadata JSON
+          #
+          obfuscator.obfuscate ::JSON.dump(rmd)
         end
       rescue => e
         NewRelic::Agent.logger.error "error during get_response_metadata", e

data/lib/new_relic/agent/guid_generator.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+# This file is distributed under New Relic's license terms.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
+
+module NewRelic
+  module Agent
+    module GuidGenerator
+
+      HEX_DIGITS = (0..15).map{|i| i.to_s(16)}
+
+      module_function
+
+      # This method intentionally does not use SecureRandom, because it relies
+      # on urandom, which raises an exception in MRI when the interpreter runs
+      # out of allocated file descriptors.
+      # The guids generated by this method may not be _secure_, but they are
+      # random enough for our purposes.
+      def generate_guid length = 16
+        guid = ''
+        length.times do |a|
+          guid << HEX_DIGITS[rand(16)]
+        end
+        guid
+      end
+
+    end
+  end
+end

data/lib/new_relic/agent/harvester.rb

@@ -1,6 +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.
+# See https://github.com/newrelic/newrelic-ruby-agent/blob/main/LICENSE for complete details.
 
 module NewRelic
   module Agent

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/newrelic-ruby-agent/blob/main/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