newrelic_rpm 6.8.0.360 → 8.13.1

data/lib/new_relic/agent/threading/backtrace_service.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
   module Agent
@@ -20,10 +20,10 @@ module NewRelic
         end
 
         attr_reader :worker_loop, :buffer, :effective_polling_period,
-                    :overhead_percent_threshold
+          :overhead_percent_threshold
         attr_accessor :worker_thread, :profile_agent_code
 
-        def initialize(event_listener=nil)
+        def initialize(event_listener = nil)
           @profiles = {}
           @buffer = {}
           @last_poll = nil
@@ -52,7 +52,7 @@ module NewRelic
           @running
         end
 
-        def subscribe(transaction_name, command_arguments={})
+        def subscribe(transaction_name, command_arguments = {})
           if self.class.is_resque?
             NewRelic::Agent.logger.info("Backtracing threads on Resque is not supported, so not subscribing transaction '#{transaction_name}'")
             return
@@ -105,7 +105,7 @@ module NewRelic
           @lock.synchronize do
             if @profiles[transaction_name]
               profile = @profiles.delete(transaction_name)
-              profile.finished_at = Time.now
+              profile.finished_at = Process.clock_gettime(Process::CLOCK_REALTIME)
               @profiles[transaction_name] = ThreadProfile.new(profile.command_arguments)
               profile
             end
@@ -113,11 +113,11 @@ module NewRelic
         end
 
         def on_transaction_finished(payload)
-          name     = payload[:name]
-          start    = payload[:start_timestamp]
+          name = payload[:name]
+          start = payload[:start_timestamp]
           duration = payload[:duration]
-          thread   = payload[:thread] || Thread.current
-          bucket   = payload[:bucket]
+          thread = payload[:thread] || Thread.current
+          bucket = payload[:bucket]
           @lock.synchronize do
             backtraces = @buffer.delete(thread)
             if backtraces && @profiles.has_key?(name)
@@ -151,6 +151,7 @@ module NewRelic
         # This method is expected to be called with @lock held
         def stop
           return unless @running
+
           @running = false
           self.worker_loop.stop
 
@@ -163,7 +164,7 @@ module NewRelic
         end
 
         def poll
-          poll_start = Time.now
+          poll_start = Process.clock_gettime(Process::CLOCK_REALTIME)
 
           @lock.synchronize do
             AgentThread.list.each do |thread|
@@ -173,7 +174,7 @@ module NewRelic
             @buffer.delete_if { |thread, _| !thread.alive? }
           end
 
-          end_time = Time.now
+          end_time = Process.clock_gettime(Process::CLOCK_REALTIME)
           adjust_polling_time(end_time, poll_start)
           record_supportability_metrics(end_time, poll_start)
         end
@@ -197,7 +198,7 @@ module NewRelic
         # This method is expected to be called with @lock held
         def watching_for_transaction?
           @profiles.size > 1 ||
-          (@profiles.size == 1 && @profiles[ALL_TRANSACTIONS].nil?)
+            (@profiles.size == 1 && @profiles[ALL_TRANSACTIONS].nil?)
         end
 
         def allowed_bucket?(bucket)
@@ -230,7 +231,7 @@ module NewRelic
           bucket = AgentThread.bucket_thread(thread, @profile_agent_code)
 
           if need_backtrace?(bucket)
-            timestamp = Time.now.to_f
+            timestamp = Process.clock_gettime(Process::CLOCK_REALTIME)
             backtrace = AgentThread.scrub_backtrace(thread, @profile_agent_code)
             aggregate_global_backtrace(backtrace, bucket, thread)
             buffer_backtrace_for_thread(thread, timestamp, backtrace, bucket)
@@ -277,7 +278,6 @@ module NewRelic
           end
           @last_poll = poll_start
         end
-
       end
     end
   end

data/lib/new_relic/agent/threading/thread_profile.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 'set'
 require 'new_relic/agent/worker_loop'
@@ -11,27 +11,25 @@ require 'new_relic/agent/threading/backtrace_node'
 module NewRelic
   module Agent
     module Threading
-
       class ThreadProfile
-
         attr_reader :profile_id, :traces, :sample_period,
           :duration, :poll_count, :backtrace_count, :failure_count,
           :created_at, :command_arguments, :profile_agent_code
         attr_accessor :finished_at
 
-        def initialize(command_arguments={})
-          @command_arguments  = command_arguments
-          @profile_id         = command_arguments.fetch('profile_id', -1)
-          @duration           = command_arguments.fetch('duration', 120)
-          @sample_period      = command_arguments.fetch('sample_period', 0.1)
+        def initialize(command_arguments = {})
+          @command_arguments = command_arguments
+          @profile_id = command_arguments.fetch('profile_id', -1)
+          @duration = command_arguments.fetch('duration', 120)
+          @sample_period = command_arguments.fetch('sample_period', 0.1)
           @profile_agent_code = command_arguments.fetch('profile_agent_code', false)
           @finished = false
 
           @traces = {
-            :agent      => BacktraceRoot.new,
+            :agent => BacktraceRoot.new,
             :background => BacktraceRoot.new,
-            :other      => BacktraceRoot.new,
-            :request    => BacktraceRoot.new
+            :other => BacktraceRoot.new,
+            :request => BacktraceRoot.new
           }
 
           @poll_count = 0
@@ -39,7 +37,7 @@ module NewRelic
           @failure_count = 0
           @unique_threads = []
 
-          @created_at = Time.now
+          @created_at = Process.clock_gettime(Process::CLOCK_REALTIME)
         end
 
         def requested_period
@@ -56,6 +54,7 @@ module NewRelic
 
         def unique_thread_count
           return 0 if @unique_threads.nil?
+
           @unique_threads.length
         end
 
@@ -69,27 +68,29 @@ module NewRelic
           end
         end
 
-        def convert_N_trace_nodes_to_arrays(count_to_keep) #THREAD_LOCAL_ACCESS
+        def convert_N_trace_nodes_to_arrays(count_to_keep) # THREAD_LOCAL_ACCESS
           all_nodes = @traces.values.map { |n| n.flattened }.flatten
 
-          NewRelic::Agent.instance.stats_engine.
-            tl_record_supportability_metric_count("ThreadProfiler/NodeCount", all_nodes.size)
+          NewRelic::Agent.instance.stats_engine
+            .tl_record_supportability_metric_count("ThreadProfiler/NodeCount", all_nodes.size)
 
           all_nodes.sort! do |a, b|
             # we primarily prefer higher runnable_count
             comparison = b.runnable_count <=> a.runnable_count
             # we secondarily prefer lower depth
-            comparison = a.depth          <=> b.depth if comparison == 0
-            # it is thus impossible for any child to preceed their parent
+            comparison = a.depth <=> b.depth if comparison == 0
+            # it is thus impossible for any child to precede their parent
             comparison
           end
 
           all_nodes.each_with_index do |n, i|
             break if i >= count_to_keep
+
             n.mark_for_array_conversion
           end
           all_nodes.each_with_index do |n, i|
             break if i >= count_to_keep
+
             n.complete_array_conversion
           end
         end
@@ -102,9 +103,9 @@ module NewRelic
           convert_N_trace_nodes_to_arrays(THREAD_PROFILER_NODES)
 
           {
-            "OTHER"      => @traces[:other     ].as_array,
-            "REQUEST"    => @traces[:request   ].as_array,
-            "AGENT"      => @traces[:agent     ].as_array,
+            "OTHER" => @traces[:other].as_array,
+            "REQUEST" => @traces[:request].as_array,
+            "AGENT" => @traces[:agent].as_array,
             "BACKGROUND" => @traces[:background].as_array
           }
         end
@@ -124,11 +125,10 @@ module NewRelic
         end
 
         def to_log_description
-          "#<ThreadProfile:#{object_id} "\
-            "@profile_id: #{profile_id} "\
+          "#<ThreadProfile:#{object_id} " \
+            "@profile_id: #{profile_id} " \
             "@command_arguments=#{@command_arguments.inspect}>"
         end
-
       end
     end
   end

data/lib/new_relic/agent/timestamp_sampled_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
 
 require 'new_relic/agent/heap'
 

data/lib/new_relic/agent/tracer.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/transaction'
 require 'new_relic/agent/transaction/segment'
@@ -86,9 +86,9 @@ module NewRelic
         #
         # @api public
         def in_transaction(name: nil,
-                           partial_name: nil,
-                           category: nil,
-                           options: {})
+          partial_name: nil,
+          category:,
+          options: {})
 
           finishable = start_transaction_or_segment(
             name: name,
@@ -102,9 +102,9 @@ module NewRelic
             # only wrap the yield to be absolutely sure we don't report agent
             # problems as app errors
             yield
-          rescue => e
-            current_transaction.notice_error(e)
-            raise e
+          rescue => exception
+            current_transaction.notice_error(exception)
+            raise
           ensure
             finishable.finish if finishable
           end
@@ -120,7 +120,7 @@ module NewRelic
         #   New-Relic-specific prefix
         #
         # @param [Symbol] category +:web+ for web transactions or
-        #   +:background+ for background transactions
+        #   +:task+ for background transactions
         #
         # @param [Hash] options reserved for New Relic internal use
         #
@@ -130,15 +130,11 @@ module NewRelic
         #
         # @api public
         def start_transaction_or_segment(name: nil,
-                                         partial_name: nil,
-                                         category: nil,
-                                         options: {})
-          if name.nil? && partial_name.nil?
-            raise ArgumentError, 'missing required argument: name or partial_name'
-          end
-          if category.nil?
-            raise ArgumentError, 'missing required argument: category'
-          end
+          partial_name: nil,
+          category:,
+          options: {})
+
+          raise ArgumentError, 'missing required argument: name or partial_name' if name.nil? && partial_name.nil?
 
           if name
             options[:transaction_name] = name
@@ -154,25 +150,20 @@ module NewRelic
           else
             Transaction.start_new_transaction(state, category, options)
           end
-
         rescue ArgumentError
           raise
-        rescue => e
-          log_error('start_transaction_or_segment', e)
+        rescue => exception
+          log_error('start_transaction_or_segment', exception)
         end
 
         # Takes name or partial_name and a category.
         # Returns a transaction instance or nil
-        def start_transaction(name: nil,
-                              partial_name: nil,
-                              category: nil,
-                              **options)
-          if name.nil? && partial_name.nil?
-            raise ArgumentError, 'missing required argument: name or partial_name'
-          end
-          if category.nil?
-            raise ArgumentError, 'missing required argument: category'
-          end
+        def start_transaction(category:,
+          name: nil,
+          partial_name: nil,
+          **options)
+
+          raise ArgumentError, 'missing required argument: name or partial_name' if name.nil? && partial_name.nil?
 
           return current_transaction if current_transaction
 
@@ -186,22 +177,24 @@ module NewRelic
           end
 
           Transaction.start_new_transaction(state,
-                                            category,
-                                            options)
+            category,
+            options)
         rescue ArgumentError
           raise
-        rescue => e
-          log_error('start_transaction', e)
+        rescue => exception
+          log_error('start_transaction', exception)
         end
 
         def create_distributed_trace_payload
           return unless txn = current_transaction
-          txn.create_distributed_trace_payload
+
+          txn.distributed_tracer.create_distributed_trace_payload
         end
 
         def accept_distributed_trace_payload(payload)
           return unless txn = current_transaction
-          txn.accept_distributed_trace_payload(payload)
+
+          txn.distributed_tracer.accept_distributed_trace_payload(payload)
         end
 
         # Returns the currently active segment in the transaction in
@@ -211,6 +204,7 @@ module NewRelic
         # @api public
         def current_segment
           return unless txn = current_transaction
+
           txn.current_segment
         end
 
@@ -238,21 +232,17 @@ module NewRelic
         #   +finish+ on it at the end of the code you're tracing
         #
         # @api public
-        def start_segment(name:nil,
-                          unscoped_metrics:nil,
-                          start_time: nil,
-                          parent: nil)
-
-          # ruby 2.0.0 does not support required kwargs
-          raise ArgumentError, 'missing required argument: name' if name.nil?
-
-          segment = Transaction::Segment.new name, unscoped_metrics, start_time
-          start_and_add_segment segment, parent
+        def start_segment(name:,
+          unscoped_metrics: nil,
+          start_time: nil,
+          parent: nil)
 
+          segment = Transaction::Segment.new(name, unscoped_metrics, start_time)
+          start_and_add_segment(segment, parent)
         rescue ArgumentError
           raise
-        rescue => e
-          log_error('start_segment', e)
+        rescue => exception
+          log_error('start_segment', exception)
         end
 
         UNKNOWN = "Unknown".freeze
@@ -294,24 +284,23 @@ module NewRelic
         #
         # @api public
         def start_datastore_segment(product: nil,
-                                    operation: nil,
-                                    collection: nil,
-                                    host: nil,
-                                    port_path_or_id: nil,
-                                    database_name: nil,
-                                    start_time: nil,
-                                    parent: nil)
+          operation: nil,
+          collection: nil,
+          host: nil,
+          port_path_or_id: nil,
+          database_name: nil,
+          start_time: nil,
+          parent: nil)
 
           product ||= UNKNOWN
           operation ||= OTHER
 
-          segment = Transaction::DatastoreSegment.new product, operation, collection, host, port_path_or_id, database_name
-          start_and_add_segment segment, parent
-
+          segment = Transaction::DatastoreSegment.new(product, operation, collection, host, port_path_or_id, database_name)
+          start_and_add_segment(segment, parent)
         rescue ArgumentError
           raise
-        rescue => e
-          log_error('start_datastore_segment', e)
+        rescue => exception
+          log_error('start_datastore_segment', exception)
         end
 
         # Creates and starts an external request segment using the
@@ -341,41 +330,45 @@ module NewRelic
         #   you're tracing
         #
         # @api public
-        def start_external_request_segment(library: nil,
-                                           uri: nil,
-                                           procedure: nil,
-                                           start_time: nil,
-                                           parent: nil)
-
-          # ruby 2.0.0 does not support required kwargs
-          raise ArgumentError, 'missing required argument: library' if library.nil?
-          raise ArgumentError, 'missing required argument: uri' if uri.nil?
-          raise ArgumentError, 'missing required argument: procedure' if procedure.nil?
-
-          segment = Transaction::ExternalRequestSegment.new library, uri, procedure, start_time
-          start_and_add_segment segment, parent
-
+        def start_external_request_segment(library:,
+          uri:,
+          procedure:,
+          start_time: nil,
+          parent: nil)
+
+          segment = Transaction::ExternalRequestSegment.new(library, uri, procedure, start_time)
+          start_and_add_segment(segment, parent)
         rescue ArgumentError
           raise
-        rescue => e
-          log_error('start_external_request_segment', e)
+        rescue => exception
+          log_error('start_external_request_segment', exception)
+        end
+
+        # Will potentially capture and notice an error at the
+        # segment that was executing when error occurred.
+        # if passed +segment+ is something that doesn't
+        # respond to +notice_segment_error+ then this method
+        # is effectively just a yield to the given &block
+        def capture_segment_error(segment)
+          return unless block_given?
+
+          yield
+        rescue => exception
+          if segment && segment.is_a?(Transaction::AbstractSegment)
+            segment.notice_error(exception)
+          end
+          raise
         end
 
         # For New Relic internal use only.
-        def start_message_broker_segment(action: nil,
-                                         library: nil,
-                                         destination_type: nil,
-                                         destination_name: nil,
-                                         headers: nil,
-                                         parameters: nil,
-                                         start_time: nil,
-                                         parent: nil)
-
-          # ruby 2.0.0 does not support required kwargs
-          raise ArgumentError, 'missing required argument: action' if action.nil?
-          raise ArgumentError, 'missing required argument: library' if library.nil?
-          raise ArgumentError, 'missing required argument: destination_type' if destination_type.nil?
-          raise ArgumentError, 'missing required argument: destination_name' if destination_name.nil?
+        def start_message_broker_segment(action:,
+          library:,
+          destination_type:,
+          destination_name:,
+          headers: nil,
+          parameters: nil,
+          start_time: nil,
+          parent: nil)
 
           segment = Transaction::MessageBrokerSegment.new(
             action: action,
@@ -386,12 +379,11 @@ module NewRelic
             parameters: parameters,
             start_time: start_time
           )
-          start_and_add_segment segment, parent
-
+          start_and_add_segment(segment, parent)
         rescue ArgumentError
           raise
-        rescue => e
-          log_error('start_datastore_segment', e)
+        rescue => exception
+          log_error('start_datastore_segment', exception)
         end
 
         # This method should only be used by Tracer for access to the
@@ -417,13 +409,28 @@ module NewRelic
 
         alias_method :tl_clear, :clear_state
 
+        def thread_block_with_current_transaction(*args, &block)
+          current_txn = ::Thread.current[:newrelic_tracer_state].current_transaction if ::Thread.current[:newrelic_tracer_state] && ::Thread.current[:newrelic_tracer_state].is_execution_traced?
+          proc do
+            begin
+              if current_txn
+                NewRelic::Agent::Tracer.state.current_transaction = current_txn
+                segment = NewRelic::Agent::Tracer.start_segment(name: "Ruby/Thread/#{::Thread.current.object_id}")
+              end
+              yield(*args) if block.respond_to?(:call)
+            ensure
+              segment.finish if segment
+            end
+          end
+        end
+
         private
 
-        def start_and_add_segment segment, parent = nil
+        def start_and_add_segment(segment, parent = nil)
           tracer_state = state
           if (txn = tracer_state.current_transaction) &&
-            tracer_state.tracing_enabled?
-            txn.add_segment segment, parent
+              tracer_state.tracing_enabled?
+            txn.add_segment(segment, parent)
           else
             segment.record_metrics = false
           end
@@ -440,7 +447,6 @@ module NewRelic
       # This is THE location to store thread local information during a transaction
       # Need a new piece of data? Add a method here, NOT a new thread local variable.
       class State
-
         def initialize
           @untraced = []
           @current_transaction = nil
@@ -448,7 +454,7 @@ module NewRelic
         end
 
         # This starts the timer for the transaction.
-        def reset(transaction=nil)
+        def reset(transaction = nil)
           # We purposefully don't reset @untraced or @record_sql
           # since those are managed by NewRelic::Agent.disable_* calls explicitly
           # and (more importantly) outside the scope of a transaction
@@ -458,7 +464,7 @@ module NewRelic
         end
 
         # Current transaction stack
-        attr_reader :current_transaction
+        attr_accessor :current_transaction
 
         # Execution tracing on current thread
         attr_accessor :untraced