newrelic_rpm 6.8.0.360 → 9.2.2

data/lib/new_relic/agent/event_aggregator.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.
+# frozen_string_literal: true
 
 require 'new_relic/agent/priority_sampled_buffer'
 
@@ -8,11 +8,11 @@ module NewRelic
   module Agent
     class EventAggregator
       class << self
-        def named named = nil
+        def named(named = nil)
           named ? @named = named.to_s.freeze : @named
         end
 
-        def capacity_key key = nil
+        def capacity_key(key = nil)
           key ? @capacity_key = key : @capacity_key
         end
 
@@ -20,12 +20,12 @@ module NewRelic
         # enabled. Multiple keys will be &&'d and the enabled status of the
         # aggregator will be reset when agent configuration changes.
 
-        def enabled_keys *keys
+        def enabled_keys(*keys)
           if keys.empty?
             @enabled_keys ||= []
           else
             @enabled_keys = Array(keys)
-            @enabled_fn = ->(){ @enabled_keys.all? { |k| Agent.config[k] } }
+            @enabled_fn = ->() { @enabled_keys.all? { |k| Agent.config[k] } }
           end
         end
 
@@ -35,11 +35,11 @@ module NewRelic
         # control over whether an aggregator should be enabled. The enabled fn
         # will be reevaluated after configuration changes
 
-        def enabled_fn fn = nil
+        def enabled_fn(fn = nil)
           fn ? @enabled_fn = fn : @enabled_fn
         end
 
-        def buffer_class klass = nil
+        def buffer_class(klass = nil)
           if klass
             @buffer_class = klass
           else
@@ -48,13 +48,13 @@ module NewRelic
         end
       end
 
-      def initialize events
+      def initialize(events)
         @lock = Mutex.new
-        @buffer = self.class.buffer_class.new NewRelic::Agent.config[self.class.capacity_key]
+        @buffer = self.class.buffer_class.new(NewRelic::Agent.config[self.class.capacity_key])
         @enabled = self.class.enabled_fn ? self.class.enabled_fn.call : false
         @notified_full = false
         register_capacity_callback
-        register_enabled_callback events
+        register_enabled_callback(events)
         after_initialize
       end
 
@@ -63,7 +63,7 @@ module NewRelic
       end
 
       # interface method for subclasses to override to provide post harvest functionality
-      def after_harvest metadata
+      def after_harvest(metadata)
       end
 
       def enabled?
@@ -78,11 +78,11 @@ module NewRelic
         metadata = nil
         samples = []
         @lock.synchronize do
-          samples.concat @buffer.to_a
+          samples.concat(@buffer.to_a)
           metadata = @buffer.metadata
           reset_buffer!
         end
-        after_harvest metadata
+        after_harvest(metadata)
         [reservoir_metadata(metadata), samples]
       end
 
@@ -90,15 +90,15 @@ module NewRelic
       # the buffer to ensure accuracy of buffer of metadata. We want to make sure not to
       # double count samples being merged back in from a failed harvest, yet we do not
       # want to under-count samples being merged from the PipeService.
-      def merge! payload, adjust_count = true
+      def merge!(payload, adjust_count = true)
         @lock.synchronize do
           _, samples = payload
 
           if adjust_count
-            @buffer.decrement_lifetime_counts_by samples.count
+            @buffer.decrement_lifetime_counts_by(samples.count)
           end
 
-          samples.each { |s| @buffer.append event: s }
+          samples.each { |s| @buffer.append(event: s) }
         end
       end
 
@@ -110,7 +110,7 @@ module NewRelic
 
       private
 
-      def reservoir_metadata metadata
+      def reservoir_metadata(metadata)
         {
           :reservoir_size => metadata[:capacity],
           :events_seen => metadata[:seen]
@@ -119,24 +119,25 @@ module NewRelic
 
       def register_capacity_callback
         NewRelic::Agent.config.register_callback(self.class.capacity_key) do |max_samples|
-          NewRelic::Agent.logger.debug "#{self.class.named} max_samples set to #{max_samples}"
+          NewRelic::Agent.logger.debug("#{self.class.named} max_samples set to #{max_samples}")
           @lock.synchronize do
             @buffer.capacity = max_samples
           end
         end
       end
 
-      def register_enabled_callback events
+      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."
+          ::NewRelic::Agent.logger.debug("#{self.class.named} will #{@enabled ? '' : 'not '}be sent to the New Relic service.")
         }
       end
 
       def notify_if_full
         return unless !@notified_full && @buffer.full?
-        NewRelic::Agent.logger.debug "#{self.class.named} capacity of #{@buffer.capacity} reached, beginning sampling"
+
+        NewRelic::Agent.logger.debug("#{self.class.named} capacity of #{@buffer.capacity} reached, beginning sampling")
         @notified_full = true
       end
 

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.
+# frozen_string_literal: true
 
 # EventBuffer is intended to be an abstract base class. It should not be
 # instantiated directly. Subclasses should define an `append_event` method
@@ -22,22 +22,22 @@ module NewRelic
 
       def initialize(capacity)
         @capacity = capacity
-        @items    = []
-        @seen     = 0
+        @items = []
+        @seen = 0
       end
 
       def reset!
         @items = []
-        @seen  = 0
+        @seen = 0
       end
 
       def capacity=(new_capacity)
         @capacity = new_capacity
         old_items = @items
-        @items    = []
-        old_seen  = @seen
+        @items = []
+        old_seen = @seen
         old_items.each { |i| append(i) }
-        @seen     = old_seen
+        @seen = old_seen
       end
 
       def append(x)
@@ -88,4 +88,3 @@ module NewRelic
     end
   end
 end
-

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.
+# frozen_string_literal: true
 
 module NewRelic::Agent
   # Basic mechanism for the agent instance to provide agent-wide eventing.
@@ -9,7 +9,6 @@ module NewRelic::Agent
   # While an EventListener could be used elsewhere, it's strongly expected
   # your eventing needs should be met by the agent's instance.
   class EventListener
-
     attr_accessor :runaway_threshold
 
     def initialize

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.
+# frozen_string_literal: true
 
 require 'thread'
 
@@ -10,11 +10,11 @@ module NewRelic
       class Timer
         attr_reader :next_fire_time, :event, :interval, :last_fired_at
 
-        def initialize(interval, event, repeat=false)
-          @interval      = interval
-          @event         = event
-          @repeat        = repeat
-          @started_at    = Time.now
+        def initialize(interval, event, repeat = false)
+          @interval = interval
+          @event = event
+          @repeat = repeat
+          @started_at = Process.clock_gettime(Process::CLOCK_REALTIME)
           @last_fired_at = nil
           reschedule
         end
@@ -32,8 +32,9 @@ module NewRelic
         end
 
         def calculate_next_fire_time
-          now = Time.now
+          now = Process.clock_gettime(Process::CLOCK_REALTIME)
           return now if @interval == 0
+
           fire_time = @last_fired_at || now
           while fire_time <= now
             fire_time += @interval
@@ -42,10 +43,10 @@ module NewRelic
         end
 
         def set_fired_time
-          @last_fired_at = Time.now
+          @last_fired_at = Process.clock_gettime(Process::CLOCK_REALTIME)
         end
 
-        def due?(now=Time.now)
+        def due?(now = Process.clock_gettime(Process::CLOCK_REALTIME))
           now >= @next_fire_time
         end
 
@@ -57,19 +58,19 @@ module NewRelic
       def initialize
         @self_pipe_rd, @self_pipe_wr = IO.pipe
         @event_queue = Queue.new
-        @stopped     = false
-        @timers      = {}
+        @stopped = false
+        @timers = {}
 
-        @subscriptions = Hash.new { |h,k| h[k] = [] }
-        @subscriptions[:__add_timer] << Proc.new { |t| set_timer(t) }
-        @subscriptions[:__add_event] << Proc.new { |e, blk| @subscriptions[e] << blk }
+        @subscriptions = Hash.new { |h, k| h[k] = [] }
+        @subscriptions[:__add_timer] << proc { |t| set_timer(t) }
+        @subscriptions[:__add_event] << proc { |e, blk| @subscriptions[e] << blk }
       end
 
       def set_timer(timer)
         existing_timer = @timers[timer.event]
 
         if existing_timer
-          elapsed_interval = Time.now - existing_timer.last_interval_start
+          elapsed_interval = Process.clock_gettime(Process::CLOCK_REALTIME) - existing_timer.last_interval_start
           timer.advance(elapsed_interval)
         end
 
@@ -80,8 +81,9 @@ module NewRelic
 
       def next_timeout
         return nil if @timers.empty?
-        timeout = @timers.values.map(&:next_fire_time).min - Time.now
-        timeout < 0 ? 0 : timeout
+
+        timeout = @timers.values.map(&:next_fire_time).min - Process.clock_gettime(Process::CLOCK_REALTIME)
+        [timeout, 0].max
       end
 
       def stopped?
@@ -94,13 +96,13 @@ module NewRelic
       end
 
       def run
-        ::NewRelic::Agent.logger.debug "Running event loop"
+        ::NewRelic::Agent.logger.debug('Running event loop')
         while !stopped?
           run_once
         end
       end
 
-      def run_once(nonblock=false)
+      def run_once(nonblock = false)
         wait_to_run(nonblock)
 
         prune_timers
@@ -154,12 +156,12 @@ module NewRelic
         end
 
         if !errors.empty?
-          ::NewRelic::Agent.logger.error "#{errors.size} error(s) running task for event '#{event}' in Agent Event Loop:", *errors
+          ::NewRelic::Agent.logger.error("#{errors.size} error(s) running task for event '#{event}' in Agent Event Loop:", *errors)
         end
       end
 
       def reschedule_timer_for_event(e)
-        @timers[e].reschedule if @timers[e]
+        @timers[e]&.reschedule
       end
 
       def on(event, &blk)
@@ -172,20 +174,20 @@ module NewRelic
       end
 
       def fire_every(interval, event)
-        ::NewRelic::Agent.logger.debug "Firing event #{event} every #{interval} seconds."
+        ::NewRelic::Agent.logger.debug("Firing event #{event} every #{interval} seconds.")
         fire(:__add_timer, Timer.new(interval, event, true))
       end
 
       def fire_after(interval, event)
-        ::NewRelic::Agent.logger.debug "Firing event #{event} after #{interval} seconds."
+        ::NewRelic::Agent.logger.debug("Firing event #{event} after #{interval} seconds.")
         fire(:__add_timer, Timer.new(interval, event, false))
       end
 
       def wakeup
         begin
-          @self_pipe_wr.write_nonblock '.'
+          @self_pipe_wr.write_nonblock('.')
         rescue Errno::EAGAIN
-          ::NewRelic::Agent.logger.debug "Failed to wakeup event loop"
+          ::NewRelic::Agent.logger.debug('Failed to wakeup event loop')
         end
       end
     end

data/lib/new_relic/agent/external.rb

@@ -1,10 +1,10 @@
-# 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/transaction/tracing'
-require 'new_relic/agent/cross_app_tracing'
-require 'new_relic/agent/cross_app_payload'
+require 'new_relic/agent/distributed_tracing/cross_app_tracing'
+require 'new_relic/agent/distributed_tracing/cross_app_payload'
 
 module NewRelic
   module Agent
@@ -18,44 +18,12 @@ module NewRelic
     module External
       extend self
 
-      # This method creates and starts an external request segment using the
-      # given library, URI, and procedure. This is used to time external calls
-      # made over HTTP.
-      #
-      # @param [String] library a string of the class name of the library used to
-      # make the external call, for example, 'Net::HTTP'.
-      #
-      # @param [String, URI] uri indicates the URI to which the
-      # external request is being made. The URI should begin with the protocol,
-      # for example, 'https://github.com'.
-      #
-      # @param [String] procedure the HTTP method being used for the external
-      # request as a string, for example, 'GET'.
-      #
-      # @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::Tracer.start_external_request_segment(
-          library: library,
-          uri: uri,
-          procedure: procedure
-        )
-      end
-
-      NON_HTTP_CAT_ID_HEADER  = 'NewRelicID'.freeze
+      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
+      # Process obfuscated +String+ identifying 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
       # generated by +get_request_metadata+ on the calling application.
       #
@@ -63,13 +31,13 @@ module NewRelic
       #
       # @api public
       #
-      def process_request_metadata request_metadata
+      def process_request_metadata(request_metadata)
         NewRelic::Agent.record_api_supportability_metric(:process_request_metadata)
         return unless CrossAppTracing.cross_app_enabled?
 
         state = NewRelic::Agent::Tracer.state
         if transaction = state.current_transaction
-          rmd = ::JSON.parse obfuscator.deobfuscate(request_metadata)
+          rmd = ::JSON.parse(obfuscator.deobfuscate(request_metadata))
 
           # handle/check ID
           #
@@ -78,26 +46,26 @@ module NewRelic
             #
             if txn_info = rmd[NON_HTTP_CAT_TXN_HEADER]
               payload = CrossAppPayload.new(id, transaction, txn_info)
-              transaction.cross_app_payload = payload
+              transaction.distributed_tracer.cross_app_payload = payload
 
-              CrossAppTracing.assign_intrinsic_transaction_attributes state
+              CrossAppTracing.assign_intrinsic_transaction_attributes(state)
             end
 
             # handle synthetics
             #
             if synth = rmd[NON_HTTP_CAT_SYNTHETICS_HEADER]
               transaction.synthetics_payload = synth
-              transaction.raw_synthetics_header = obfuscator.obfuscate ::JSON.dump(synth)
+              transaction.raw_synthetics_header = obfuscator.obfuscate(::JSON.dump(synth))
             end
 
           else
-            NewRelic::Agent.logger.error "error processing request metadata: invalid/non-trusted ID: '#{id}'"
+            NewRelic::Agent.logger.error("error processing request metadata: invalid/non-trusted ID: '#{id}'")
           end
 
           nil
         end
       rescue => e
-        NewRelic::Agent.logger.error 'error during process_request_metadata', e
+        NewRelic::Agent.logger.error('error during process_request_metadata', e)
       end
 
       # Obtain an obfuscated +String+ suitable for delivery across public networks that carries transaction
@@ -112,24 +80,24 @@ module NewRelic
         NewRelic::Agent.record_api_supportability_metric(:get_response_metadata)
         return unless CrossAppTracing.cross_app_enabled?
 
-        return unless (transaction = Tracer.current_transaction)
-        return unless (cross_app_payload = transaction.cross_app_payload)
+        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
         #
-        transaction.freeze_name_and_execute_if_not_ignored do
+        txn.freeze_name_and_execute_if_not_ignored do
           # build response payload
           #
           rmd = {
-            NewRelicAppData: cross_app_payload.as_json_array(NON_HTTP_CAT_CONTENT_LENGTH)
+            NewRelicAppData: payload.as_json_array(NON_HTTP_CAT_CONTENT_LENGTH)
           }
 
           # obfuscate the generated response metadata JSON
           #
-          obfuscator.obfuscate ::JSON.dump(rmd)
+          obfuscator.obfuscate(::JSON.dump(rmd))
         end
       rescue => e
-        NewRelic::Agent.logger.error "error during get_response_metadata", e
+        NewRelic::Agent.logger.error('error during get_response_metadata', e)
       end
 
       private
@@ -137,7 +105,6 @@ module NewRelic
       def obfuscator
         CrossAppTracing.obfuscator
       end
-
     end
   end
 end

data/lib/new_relic/agent/guid_generator.rb

@@ -1,28 +1,30 @@
-# 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
 
 module NewRelic
   module Agent
     module GuidGenerator
-
-      HEX_DIGITS = (0..15).map{|i| i.to_s(16)}
-
       module_function
 
+      MAX_RAND_16 = 16**16
+      MAX_RAND_32 = 16**32
       # 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
+      def generate_guid(length = 16)
+        guid = case length
+               when 16
+                 rand(MAX_RAND_16)
+               when 32
+                 rand(MAX_RAND_32)
+               else
+                 rand(16**length)
+        end.to_s(16)
+        guid.length < length ? guid.rjust(length, '0') : guid
       end
-
     end
   end
 end

data/lib/new_relic/agent/harvester.rb

@@ -1,29 +1,26 @@
-# 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
 
 module NewRelic
   module Agent
     class Harvester
-
       attr_accessor :starting_pid
 
       # Inject target for after_fork call to avoid spawning thread in tests
-      def initialize(events, after_forker=NewRelic::Agent)
+      def initialize(events, after_forker = NewRelic::Agent)
         # We intentionally don't set our pid as started at this point.
         # Startup routines must call mark_started when they consider us set!
         @starting_pid = nil
         @after_forker = after_forker
 
-        if events
-          events.subscribe(:start_transaction, &method(:on_transaction))
-        end
+        events&.subscribe(:start_transaction, &method(:on_transaction))
       end
 
       def on_transaction(*_)
         return unless restart_in_children_enabled? &&
-                        needs_restart? &&
-                        harvest_thread_enabled?
+          needs_restart? &&
+          harvest_thread_enabled?
 
         restart_harvest_thread
       end

data/lib/new_relic/agent/heap.rb

@@ -1,12 +1,12 @@
-# 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
 
 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
+    # relationship between nodes in the tree and indices in the array are as
     # follows:
     #
     # parent_index      = (child_index -  1) / 2
@@ -18,8 +18,7 @@ module NewRelic
     #
 
     class Heap
-
-      # @param [Array] items an optional array of items to intialize the heap
+      # @param [Array] items an optional array of items to initialize 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
@@ -27,7 +26,8 @@ module NewRelic
       def initialize(items = nil, &priority_fn)
         @items = []
         @priority_fn = priority_fn || ->(x) { x }
-        items.each{ |item| push(item) } if items
+        # the following line needs else branch coverage
+        items.each { |item| push(item) } if items # rubocop:disable Style/SafeNavigation
       end
 
       def [](index)
@@ -90,12 +90,12 @@ module NewRelic
         @priority_fn.call(@items[index])
       end
 
-      def parent_index_for child_index
+      def parent_index_for(child_index)
         (child_index - 1) / 2
       end
 
-      def left_child_index_for parent_index
-        2 * parent_index + 1
+      def left_child_index_for(parent_index)
+        parent_index * 2 + 1
       end
 
       def right_sibling_smaller?(lchild_index)
@@ -135,6 +135,5 @@ module NewRelic
         @items[i], @items[j] = @items[j], @items[i]
       end
     end
-
   end
 end