newrelic_rpm 6.15.0 → 9.7.1

data/lib/new_relic/agent/threading/backtrace_service.rb

@@ -1,12 +1,12 @@
-# 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.
+# frozen_string_literal: true
 
 module NewRelic
   module Agent
     module Threading
       class BacktraceService
-        ALL_TRANSACTIONS = "**ALL**".freeze
+        ALL_TRANSACTIONS = '**ALL**'.freeze
 
         def self.is_supported?
           !is_resque?
@@ -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
@@ -41,9 +41,7 @@ module NewRelic
             @overhead_percent_threshold = new_value
           end
 
-          if event_listener
-            event_listener.subscribe(:transaction_finished, &method(:on_transaction_finished))
-          end
+          event_listener&.subscribe(:transaction_finished, &method(:on_transaction_finished))
         end
 
         # Public interface
@@ -52,7 +50,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 +103,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 +111,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 +149,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 +162,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 +172,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 +196,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)
@@ -220,9 +219,7 @@ module NewRelic
 
         # This method is expected to be called with @lock held.
         def aggregate_global_backtrace(backtrace, bucket, thread)
-          if @profiles[ALL_TRANSACTIONS]
-            @profiles[ALL_TRANSACTIONS].aggregate(backtrace, bucket, thread)
-          end
+          @profiles[ALL_TRANSACTIONS]&.aggregate(backtrace, bucket, thread)
         end
 
         # This method is expected to be called with @lock held.
@@ -230,7 +227,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 +274,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/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,10 +103,10 @@ 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,
-            "BACKGROUND" => @traces[:background].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,13 +1,13 @@
-# 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.
+# frozen_string_literal: true
 
 require 'new_relic/agent/heap'
 
 module NewRelic
   module Agent
     class TimestampSampledBuffer < PrioritySampledBuffer
-      TIMESTAMP_KEY = "timestamp".freeze
+      TIMESTAMP_KEY = 'timestamp'.freeze
 
       private
 

data/lib/new_relic/agent/tracer.rb

@@ -1,7 +1,8 @@
-# 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.
+# frozen_string_literal: true
 
+require 'fiber'
 require 'new_relic/agent/transaction'
 require 'new_relic/agent/transaction/segment'
 require 'new_relic/agent/transaction/datastore_segment'
@@ -65,9 +66,10 @@ module NewRelic
         #
         # @api public
         def transaction_sampled?
-          if txn = current_transaction
-            txn.sampled?
-          end
+          txn = current_transaction
+          return false unless txn
+
+          txn.sampled?
         end
         alias_method :sampled?, :transaction_sampled?
 
@@ -86,9 +88,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,
@@ -106,7 +108,7 @@ module NewRelic
             current_transaction.notice_error(exception)
             raise
           ensure
-            finishable.finish if finishable
+            finishable&.finish
           end
         end
 
@@ -130,15 +132,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,7 +152,6 @@ module NewRelic
           else
             Transaction.start_new_transaction(state, category, options)
           end
-
         rescue ArgumentError
           raise
         rescue => exception
@@ -163,16 +160,12 @@ module NewRelic
 
         # 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,8 +179,8 @@ module NewRelic
           end
 
           Transaction.start_new_transaction(state,
-                                            category,
-                                            options)
+            category,
+            options)
         rescue ArgumentError
           raise
         rescue => exception
@@ -196,11 +189,13 @@ module NewRelic
 
         def create_distributed_trace_payload
           return unless txn = current_transaction
+
           txn.distributed_tracer.create_distributed_trace_payload
         end
 
         def accept_distributed_trace_payload(payload)
           return unless txn = current_transaction
+
           txn.distributed_tracer.accept_distributed_trace_payload(payload)
         end
 
@@ -211,6 +206,7 @@ module NewRelic
         # @api public
         def current_segment
           return unless txn = current_transaction
+
           txn.current_segment
         end
 
@@ -238,25 +234,21 @@ 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 => exception
           log_error('start_segment', exception)
         end
 
-        UNKNOWN = "Unknown".freeze
-        OTHER = "other".freeze
+        UNKNOWN = 'Unknown'.freeze
+        OTHER = 'other'.freeze
 
         # Creates and starts a datastore segment used to time
         # datastore operations.
@@ -294,20 +286,19 @@ 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 => exception
@@ -341,20 +332,14 @@ 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 => exception
@@ -363,34 +348,28 @@ module NewRelic
 
         # Will potentially capture and notice an error at the
         # segment that was executing when error occurred.
-        # if passed +segment+ is something that doesn't 
+        # 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
+        def capture_segment_error(segment)
           return unless block_given?
+
           yield
         rescue => exception
-          if segment && segment.is_a?(Transaction::AbstractSegment)
-            segment.notice_error exception
-          end
+          # needs else branch coverage
+          segment.notice_error(exception) if segment&.is_a?(Transaction::AbstractSegment)
           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,
@@ -401,8 +380,7 @@ module NewRelic
             parameters: parameters,
             start_time: start_time
           )
-          start_and_add_segment segment, parent
-
+          start_and_add_segment(segment, parent)
         rescue ArgumentError
           raise
         rescue => exception
@@ -432,13 +410,42 @@ module NewRelic
 
         alias_method :tl_clear, :clear_state
 
+        def current_segment_key
+          ::Fiber.current.object_id
+        end
+
+        def thread_tracing_enabled?
+          NewRelic::Agent.config[:'instrumentation.thread.tracing']
+        end
+
+        def thread_block_with_current_transaction(segment_name: nil, parent: nil, &block)
+          parent ||= current_segment
+          current_txn = ::Thread.current[:newrelic_tracer_state]&.current_transaction if ::Thread.current[:newrelic_tracer_state]&.is_execution_traced?
+          proc do |*args|
+            begin
+              if current_txn && !current_txn.finished?
+                NewRelic::Agent::Tracer.state.current_transaction = current_txn
+                ::Thread.current[:newrelic_thread_span_parent] = parent
+                current_txn.async = true
+                segment_name = "#{segment_name}/Thread#{::Thread.current.object_id}/Fiber#{::Fiber.current.object_id}" if NewRelic::Agent.config[:'thread_ids_enabled']
+                segment = NewRelic::Agent::Tracer.start_segment(name: segment_name, parent: parent) if segment_name
+              end
+              NewRelic::Agent::Tracer.capture_segment_error(segment) do
+                yield(*args)
+              end
+            ensure
+              ::NewRelic::Agent::Transaction::Segment.finish(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
@@ -455,7 +462,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
@@ -463,7 +469,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
@@ -473,7 +479,7 @@ module NewRelic
         end
 
         # Current transaction stack
-        attr_reader :current_transaction
+        attr_accessor :current_transaction
 
         # Execution tracing on current thread
         attr_accessor :untraced
@@ -483,7 +489,8 @@ module NewRelic
         end
 
         def pop_traced
-          @untraced.pop if @untraced
+          # needs else branch coverage
+          @untraced.pop if @untraced # rubocop:disable Style/SafeNavigation
         end
 
         def is_execution_traced?
@@ -503,7 +510,5 @@ module NewRelic
         attr_accessor :sql_sampler_transaction_data
       end
     end
-
-    TransactionState = Tracer
   end
 end