newrelic_rpm 5.7.0.350 → 9.0.0

data/lib/new_relic/agent/vm/snapshot.rb

@@ -1,18 +1,18 @@
-# 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 VM
       class Snapshot
         attr_accessor :gc_total_time, :gc_runs, :major_gc_count, :minor_gc_count,
-                      :total_allocated_object, :heap_live, :heap_free,
-                      :method_cache_invalidations, :constant_cache_invalidations,
-                      :thread_count, :taken_at
+          :total_allocated_object, :heap_live, :heap_free,
+          :method_cache_invalidations, :constant_cache_invalidations,
+          :constant_cache_misses, :thread_count, :taken_at
 
         def initialize
-          @taken_at = Time.now.to_f
+          @taken_at = Process.clock_gettime(Process::CLOCK_REALTIME)
         end
       end
     end

data/lib/new_relic/agent/vm.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/language_support'
 require 'new_relic/agent/vm/mri_vm'

data/lib/new_relic/agent/worker_loop.rb

@@ -1,24 +1,22 @@
-# 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'
 
 module NewRelic
   module Agent
-
     # A worker loop executes a set of registered tasks on a single thread.
     # A task is a proc or block with a specified call period in seconds.
     class WorkerLoop
-
       attr_accessor :period, :propagate_errors
       attr_reader :iterations
 
       # Optional argument :duration (in seconds) for how long the worker loop runs
       # or :limit (integer) for max number of iterations
-      def initialize(opts={})
+      def initialize(opts = {})
         @should_run = true
-        @next_invocation_time = Time.now
+        @next_invocation_time = Process.clock_gettime(Process::CLOCK_REALTIME)
         @period = 60.0
         @duration = opts[:duration]
         @limit = opts[:limit]
@@ -34,7 +32,7 @@ module NewRelic
         @should_run = true
         @iterations = 0
 
-        now = Time.now
+        now = Process.clock_gettime(Process::CLOCK_REALTIME)
         @deadline = now + @duration if @duration
         @next_invocation_time = (now + @period)
       end
@@ -42,9 +40,9 @@ module NewRelic
       # Run infinitely, calling the registered tasks at their specified
       # call periods.  The caller is responsible for creating the thread
       # that runs this worker loop.  This will run the task immediately.
-      def run(period=nil, &block)
+      def run(period = nil, &block)
         setup(period, block)
-        while keep_running? do
+        while keep_running?
           sleep_time = schedule_next_invocation
           sleep(sleep_time) if sleep_time > 0
           run_task if keep_running?
@@ -53,11 +51,11 @@ module NewRelic
       end
 
       def schedule_next_invocation
-        now = Time.now
+        now = Process.clock_gettime(Process::CLOCK_REALTIME)
         while @next_invocation_time <= now && @period > 0
           @next_invocation_time += @period
         end
-        @next_invocation_time - Time.now
+        @next_invocation_time - Process.clock_gettime(Process::CLOCK_REALTIME)
       end
 
       # a simple accessor for @should_run
@@ -66,7 +64,7 @@ module NewRelic
       end
 
       def under_duration?
-        !@deadline || Time.now < @deadline
+        !@deadline || Process.clock_gettime(Process::CLOCK_REALTIME) < @deadline
       end
 
       def under_limit?
@@ -90,7 +88,7 @@ module NewRelic
             raise
           rescue => e
             # Don't blow out the stack for anything that hasn't already propagated
-            ::NewRelic::Agent.logger.error "Error running task in Agent Worker Loop:", e
+            ::NewRelic::Agent.logger.error("Error running task in Agent Worker Loop:", e)
           end
         end
       end

data/lib/new_relic/agent.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 'forwardable'
 
@@ -26,16 +26,15 @@ module NewRelic
 
     require 'new_relic/version'
     require 'new_relic/local_environment'
-    require 'new_relic/metrics'
     require 'new_relic/metric_spec'
     require 'new_relic/metric_data'
     require 'new_relic/noticed_error'
+    require 'new_relic/agent/noticeable_error'
     require 'new_relic/supportability_helper'
 
     require 'new_relic/agent/encoding_normalizer'
     require 'new_relic/agent/stats'
     require 'new_relic/agent/chained_call'
-    require 'new_relic/agent/cross_app_monitor'
     require 'new_relic/agent/agent'
     require 'new_relic/agent/method_tracer'
     require 'new_relic/agent/worker_loop'
@@ -45,8 +44,10 @@ module NewRelic
     require 'new_relic/agent/sql_sampler'
     require 'new_relic/agent/commands/thread_profiler_session'
     require 'new_relic/agent/error_collector'
+    require 'new_relic/agent/error_filter'
     require 'new_relic/agent/sampler'
     require 'new_relic/agent/database'
+    require 'new_relic/agent/database_adapter'
     require 'new_relic/agent/datastores'
     require 'new_relic/agent/pipe_channel_manager'
     require 'new_relic/agent/configuration'
@@ -55,6 +56,11 @@ module NewRelic
     require 'new_relic/agent/system_info'
     require 'new_relic/agent/external'
     require 'new_relic/agent/deprecator'
+    require 'new_relic/agent/logging'
+    require 'new_relic/agent/distributed_tracing'
+    require 'new_relic/agent/attribute_processing'
+    require 'new_relic/agent/linking_metadata'
+    require 'new_relic/agent/local_log_decorator'
 
     require 'new_relic/agent/instrumentation/controller_instrumentation'
 
@@ -76,7 +82,11 @@ module NewRelic
     class ForceDisconnectException < StandardError; end
 
     # An exception that forces an agent to restart.
-    class ForceRestartException < StandardError; end
+    class ForceRestartException < StandardError
+      def message
+        "#{super}, restarting."
+      end
+    end
 
     # Used to blow out of a periodic task without logging a an error, such as for routine
     # failures.
@@ -92,8 +102,6 @@ module NewRelic
     # An error while serializing data for the collector
     class SerializationError < StandardError; end
 
-    class BackgroundLoadingError < StandardError; end
-
     # placeholder name used when we cannot determine a transaction's name
     UNKNOWN_METRIC = '(unknown)'.freeze
 
@@ -101,21 +109,23 @@ module NewRelic
     @logger = nil
     @tracer_lock = Mutex.new
     @tracer_queue = []
+    @metrics_already_recorded = Set.new
 
     # The singleton Agent instance.  Used internally.
-    def agent #:nodoc:
+    def agent # :nodoc:
       return @agent if @agent
+
       NewRelic::Agent.logger.warn("Agent unavailable as it hasn't been started.")
       NewRelic::Agent.logger.warn(caller.join("\n"))
       nil
     end
 
-    def agent=(new_instance)#:nodoc:
+    def agent=(new_instance) # :nodoc:
       @agent = new_instance
       add_deferred_method_tracers_now
     end
 
-    alias instance agent #:nodoc:
+    alias instance agent # :nodoc:
 
     # Primary interface to logging is fronted by this accessor
     # Access via ::NewRelic::Agent.logger
@@ -131,20 +141,22 @@ module NewRelic
     # is initialized; these methods enable us to defer these calls
     # until we have started up and can process them.
     #
-    def add_or_defer_method_tracer(receiver, method_name, metric_name_code, options)
+    def add_or_defer_method_tracer(receiver, method_name, metric_name, options)
       @tracer_lock.synchronize do
+        options[:code_information] = NewRelic::Agent::MethodTracerHelpers.code_information(receiver, method_name)
+
         if @agent
-          receiver.send(:_add_method_tracer_now, method_name, metric_name_code, options)
+          receiver.send(:_nr_add_method_tracer_now, method_name, metric_name, options)
         else
-          @tracer_queue << [receiver, method_name, metric_name_code, options]
+          @tracer_queue << [receiver, method_name, metric_name, options]
         end
       end
     end
 
     def add_deferred_method_tracers_now
       @tracer_lock.synchronize do
-        @tracer_queue.each do |receiver, method_name, metric_name_code, options|
-          receiver.send(:_add_method_tracer_now, method_name, metric_name_code, options)
+        @tracer_queue.each do |receiver, method_name, metric_name, options|
+          receiver.send(:_nr_add_method_tracer_now, method_name, metric_name, options)
         end
 
         @tracer_queue = []
@@ -179,25 +191,25 @@ module NewRelic
     # This method is safe to use from any thread.
     #
     # @api public
-    def record_metric(metric_name, value) #THREAD_LOCAL_ACCESS
+    def record_metric(metric_name, value) # THREAD_LOCAL_ACCESS
       record_api_supportability_metric(:record_metric)
 
       return unless agent
 
       if value.is_a?(Hash)
         stats = NewRelic::Agent::Stats.new
-
-        stats.call_count = value[:count] if value[:count]
-        stats.total_call_time = value[:total] if value[:total]
-        stats.total_exclusive_time = value[:total] if value[:total]
-        stats.min_call_time = value[:min] if value[:min]
-        stats.max_call_time = value[:max] if value[:max]
-        stats.sum_of_squares = value[:sum_of_squares] if value[:sum_of_squares]
-        value = stats
+        value = stats.hash_merge(value)
       end
+
       agent.stats_engine.tl_record_unscoped_metrics(metric_name, value)
     end
 
+    def record_metric_once(metric_name, value = 0.0)
+      return unless @metrics_already_recorded.add?(metric_name)
+
+      record_metric(metric_name, value)
+    end
+
     # Increment a simple counter metric.
     #
     # +metric_name+ should follow a slash separated path convention. Application
@@ -209,14 +221,15 @@ module NewRelic
 
     SUPPORTABILITY_INCREMENT_METRIC = 'Supportability/API/increment_metric'.freeze
 
-    def increment_metric(metric_name, amount=1) #THREAD_LOCAL_ACCESS
+    def increment_metric(metric_name, amount = 1) # THREAD_LOCAL_ACCESS
       return unless agent
+
       if amount == 1
         metrics = [metric_name, SUPPORTABILITY_INCREMENT_METRIC]
-        agent.stats_engine.tl_record_unscoped_metrics(metrics) {|stats| stats.increment_count}
+        agent.stats_engine.tl_record_unscoped_metrics(metrics) { |stats| stats.increment_count }
       else
-        agent.stats_engine.tl_record_unscoped_metrics(metric_name) {|stats| stats.increment_count(amount)}
-        agent.stats_engine.tl_record_unscoped_metrics(SUPPORTABILITY_INCREMENT_METRIC) {|stats| stats.increment_count}
+        agent.stats_engine.tl_record_unscoped_metrics(metric_name) { |stats| stats.increment_count(amount) }
+        agent.stats_engine.tl_record_unscoped_metrics(SUPPORTABILITY_INCREMENT_METRIC) { |stats| stats.increment_count }
       end
     end
 
@@ -225,7 +238,7 @@ module NewRelic
     # @!group Recording custom errors
 
     # Set a filter to be applied to errors that the Ruby Agent will
-    # track.  The block should evalute to the exception to track
+    # track.  The block should evaluate to the exception to track
     # (which could be different from the original exception) or nil to
     # ignore this exception.
     #
@@ -273,17 +286,11 @@ module NewRelic
     #
     # @api public
     #
-    def notice_error(exception, options={})
+    def notice_error(exception, options = {})
       record_api_supportability_metric(:notice_error)
 
-      if options.has_key?(:trace_only)
-        NewRelic::Agent.logger.log_once(:warn, :trace_only_deprecated,
-          'Passing the :trace_only option to NewRelic::Agent.notice_error is deprecated. Please use :expected instead.')
-        options[:expected] = options.delete(:trace_only)
-      end
-
       Transaction.notice_error(exception, options)
-      nil # don't return a noticed error datastructure. it can only hurt.
+      nil # don't return a noticed error data structure. it can only hurt.
     end
 
     # @!endgroup
@@ -345,11 +352,11 @@ module NewRelic
     #
     # @api public
     #
-    def manual_start(options={})
-      record_api_supportability_metric(:manual_start)
-
+    def manual_start(options = {})
       raise "Options must be a hash" unless Hash === options
-      NewRelic::Control.instance.init_plugin({ :agent_enabled => true, :sync_startup => true }.merge(options))
+
+      NewRelic::Control.instance.init_plugin({:agent_enabled => true, :sync_startup => true}.merge(options))
+      record_api_supportability_metric(:manual_start)
     end
 
     # Register this method as a callback for processes that fork
@@ -364,7 +371,7 @@ module NewRelic
     # jobs or other work.  If you are doing this with a web dispatcher
     # that forks worker processes then you will need to force the
     # agent to reconnect, which it won't do by default.  Passenger and
-    # Rainbows and Unicorn are already handled, nothing special needed for them.
+    # Unicorn are already handled, nothing special needed for them.
     #
     # Options:
     # * <tt>:force_reconnect => true</tt> to force the spawned process to
@@ -377,7 +384,7 @@ module NewRelic
     #
     # @api public
     #
-    def after_fork(options={})
+    def after_fork(options = {})
       record_api_supportability_metric(:after_fork)
       agent.after_fork(options) if agent
     end
@@ -389,7 +396,7 @@ module NewRelic
     #
     # @api public
     #
-    def shutdown(options={})
+    def shutdown(options = {})
       record_api_supportability_metric(:shutdown)
       agent.shutdown if agent
     end
@@ -414,7 +421,7 @@ module NewRelic
     #
     def add_instrumentation(file_pattern)
       record_api_supportability_metric(:add_instrumentation)
-      NewRelic::Control.instance.add_instrumentation file_pattern
+      NewRelic::Control.instance.add_instrumentation(file_pattern)
     end
 
     # Require agent testing helper methods
@@ -487,7 +494,7 @@ module NewRelic
     # Yield to the block without collecting any metrics or traces in
     # any of the subsequent calls.  If executed recursively, will keep
     # track of the first entry point and turn on tracing again after
-    # leaving that block.  This uses the thread local TransactionState.
+    # leaving that block.  This uses the thread local Tracer::State.
     #
     # @api public
     #
@@ -504,18 +511,6 @@ module NewRelic
       end
     end
 
-    # This method disables the recording of transaction traces in the given
-    # block.  See also #disable_all_tracing
-    #
-    # @api public
-    #
-    def disable_transaction_tracing
-      Deprecator.deprecate :disable_transaction_tracing,
-                           'disable_all_tracing or ignore_transaction'
-      record_api_supportability_metric(:disable_transaction_tracing)
-      yield
-    end
-
     # This method sets the state of sql recording in the transaction
     # sampler feature. Within the given block, no sql will be recorded
     #
@@ -544,13 +539,7 @@ module NewRelic
 
     # Check to see if we are capturing metrics currently on this thread.
     def tl_is_execution_traced?
-      NewRelic::Agent::TransactionState.tl_get.is_execution_traced?
-    end
-
-    # helper method to check the thread local to determine whether sql
-    # is being recorded or not
-    def tl_is_sql_recorded?
-      NewRelic::Agent::TransactionState.tl_get.is_sql_recorded?
+      NewRelic::Agent::Tracer.state.is_execution_traced?
     end
 
     # @!group Adding custom attributes to traces
@@ -563,19 +552,61 @@ module NewRelic
     # these custom attributes will also be present in the script injected into
     # the response body, making them available on Insights PageView events.
     #
+    #
+    # @param [Hash] params      A Hash of attributes to be attached to the transaction event.
+    #                           Keys should be strings or symbols, and values
+    #                           may be strings, symbols, numeric values or
+    #                           booleans.
+    #
     # @api public
     #
-    def add_custom_attributes(params) #THREAD_LOCAL_ACCESS
+    def add_custom_attributes(params) # THREAD_LOCAL_ACCESS
       record_api_supportability_metric(:add_custom_attributes)
 
-      if params.is_a? Hash
+      if params.is_a?(Hash)
         txn = Transaction.tl_current
         txn.add_custom_attributes(params) if txn
+
+        segment = ::NewRelic::Agent::Tracer.current_segment
+        if segment
+          add_new_segment_attributes(params, segment)
+        end
       else
         ::NewRelic::Agent.logger.warn("Bad argument passed to #add_custom_attributes. Expected Hash but got #{params.class}")
       end
     end
 
+    def add_new_segment_attributes(params, segment)
+      # Make sure not to override existing segment-level custom attributes
+      segment_custom_keys = segment.attributes.custom_attributes.keys.map(&:to_sym)
+      segment.add_custom_attributes(params.reject { |k, _v| segment_custom_keys.include?(k.to_sym) })
+    end
+
+    # Add custom attributes to the span event for the current span. Attributes will be visible on spans in the
+    # New Relic Distributed Tracing UI and on span events in New Relic Insights.
+    #
+    # Custom attributes will not be transmitted when +high_security+ setting is enabled or
+    # +custom_attributes+ setting is disabled.
+    #
+    # @param [Hash] params      A Hash of attributes to be attached to the span event.
+    #                           Keys should be strings or symbols, and values
+    #                           may be strings, symbols, numeric values or
+    #                           booleans.
+    #
+    # @see https://docs.newrelic.com/docs/using-new-relic/welcome-new-relic/get-started/glossary#span
+    # @api public
+    def add_custom_span_attributes(params)
+      record_api_supportability_metric(:add_custom_span_attributes)
+
+      if params.is_a?(Hash)
+        if segment = NewRelic::Agent::Tracer.current_segment
+          segment.add_custom_attributes(params)
+        end
+      else
+        ::NewRelic::Agent.logger.warn("Bad argument passed to #add_custom_span_attributes. Expected Hash but got #{params.class}")
+      end
+    end
+
     # @!endgroup
 
     # @!group Transaction naming
@@ -584,7 +615,9 @@ module NewRelic
     # apply a reasonable default based on framework routing, but in
     # cases where this is insufficient, this can be used to manually
     # control the name of the transaction.
-    # The category of transaction can be specified via the +:category+ option:
+    #
+    # The category of transaction can be specified via the +:category+ option.
+    # The following are the only valid categories:
     #
     # * <tt>:category => :controller</tt> indicates that this is a
     #   controller action and will appear with all the other actions.
@@ -603,7 +636,7 @@ module NewRelic
     #
     # @api public
     #
-    def set_transaction_name(name, options={})
+    def set_transaction_name(name, options = {})
       record_api_supportability_metric(:set_transaction_name)
       Transaction.set_overriding_transaction_name(name, options[:category])
     end
@@ -613,7 +646,7 @@ module NewRelic
     #
     # @api public
     #
-    def get_transaction_name #THREAD_LOCAL_ACCESS
+    def get_transaction_name # THREAD_LOCAL_ACCESS
       record_api_supportability_metric(:get_transaction_name)
 
       txn = Transaction.tl_current
@@ -627,15 +660,15 @@ module NewRelic
 
     # Yield to a block that is run with a database metric name context.  This means
     # the Database instrumentation will use this for the metric name if it does not
-    # otherwise know about a model.  This is re-entrant.
+    # otherwise know about a model.  This is reentrant.
     #
     # @param [String,Class,#to_s] model the DB model class
     #
     # @param [String] method the name of the finder method or other method to
     # identify the operation with.
     #
-    def with_database_metric_name(model, method = nil, product = nil, &block) #THREAD_LOCAL_ACCESS
-      if txn = Transaction.tl_current
+    def with_database_metric_name(model, method = nil, product = nil, &block)
+      if txn = Tracer.current_transaction
         txn.with_database_metric_name(model, method, product, &block)
       else
         yield
@@ -645,17 +678,53 @@ module NewRelic
     # Subscribe to events of +event_type+, calling the given +handler+
     # when one is sent.
     def subscribe(event_type, &handler)
-      agent.events.subscribe( event_type, &handler )
+      agent.events.subscribe(event_type, &handler)
     end
 
     # Fire an event of the specified +event_type+, passing it an the given +args+
     # to any registered handlers.
     def notify(event_type, *args)
-      agent.events.notify( event_type, *args )
+      agent.events.notify(event_type, *args)
     rescue
-      NewRelic::Agent.logger.debug "Ignoring exception during %p event notification" % [event_type]
+      NewRelic::Agent.logger.debug("Ignoring exception during %p event notification" % [event_type])
+    end
+
+    # @!group Trace and Entity metadata
+
+    TRACE_ID_KEY = 'trace.id'.freeze
+    SPAN_ID_KEY = 'span.id'.freeze
+    ENTITY_NAME_KEY = 'entity.name'.freeze
+    ENTITY_TYPE_KEY = 'entity.type'.freeze
+    ENTITY_GUID_KEY = 'entity.guid'.freeze
+    HOSTNAME_KEY = 'hostname'.freeze
+
+    ENTITY_TYPE = 'SERVICE'.freeze
+
+    # Returns a new hash containing trace and entity metadata that can be used
+    # to relate data to a trace or to an entity in APM.
+    #
+    # This hash includes:
+    # * trace.id    - The current trace id, if there is a current trace id. This
+    #   value may be omitted.
+    # * span.id     - The current span id, if there is a current span.  This
+    #   value may be omitted.
+    # * entity.name - The name of the current application. This is read from
+    #   the +app_name+ key in your config.  If there are multiple application
+    #   names, the first one is used.
+    # * entity.type - The entity type is hardcoded to the string +'SERVICE'+.
+    # * entity.guid - The guid of the current entity.
+    # * hostname    - The fully qualified hostname.
+    #
+    # @api public
+    def linking_metadata
+      metadata = Hash.new
+      LinkingMetadata.append_service_linking_metadata(metadata)
+      LinkingMetadata.append_trace_linking_metadata(metadata)
+      metadata
     end
 
+    # @!endgroup
+
     # @!group Manual browser monitoring configuration
 
     # This method returns a string suitable for inclusion in a page - known as
@@ -670,13 +739,16 @@ module NewRelic
     # In previous agents there was a corresponding footer required, but all the
     # work is now done by this single method.
     #
+    # @param [String] nonce The nonce to use in the javascript tag for browser instrumentation
+    #
     # @api public
     #
-    def browser_timing_header
+    def browser_timing_header(nonce = nil)
       record_api_supportability_metric(:browser_timing_header)
 
-      return "" unless agent
-      agent.javascript_instrumentor.browser_timing_header
+      return EMPTY_STR unless agent
+
+      agent.javascript_instrumentor.browser_timing_header(nonce)
     end
 
     # @!endgroup