newrelic_rpm 6.3.0.355 → 9.2.0

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/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 'fiber'
 require 'new_relic/agent/transaction'
 require 'new_relic/agent/transaction/segment'
 require 'new_relic/agent/transaction/datastore_segment'
@@ -39,6 +40,38 @@ module NewRelic
           state.current_transaction
         end
 
+        # Returns the trace_id of the current_transaction, or +nil+ if
+        # none exists.
+        #
+        # @api public
+        def current_trace_id
+          if txn = current_transaction
+            txn.trace_id
+          end
+        end
+        alias_method :trace_id, :current_trace_id
+
+        # Returns the id of the current span, or +nil+ if none exists.
+        #
+        # @api public
+        def current_span_id
+          if span = current_segment
+            span.guid
+          end
+        end
+        alias_method :span_id, :current_span_id
+
+        # Returns a boolean indicating whether the current_transaction
+        # is sampled, or +nil+ if there is no current transaction.
+        #
+        # @api public
+        def transaction_sampled?
+          if txn = current_transaction
+            txn.sampled?
+          end
+        end
+        alias_method :sampled?, :transaction_sampled?
+
         # Runs the given block of code in a transaction.
         #
         # @param [String] name reserved for New Relic internal use
@@ -54,9 +87,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,
@@ -70,11 +103,11 @@ 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
+            finishable&.finish
           end
         end
 
@@ -88,7 +121,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
         #
@@ -98,15 +131,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
@@ -122,25 +151,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
 
@@ -154,22 +178,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
@@ -179,6 +205,7 @@ module NewRelic
         # @api public
         def current_segment
           return unless txn = current_transaction
+
           txn.current_segment
         end
 
@@ -206,25 +233,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 => e
-          log_error('start_segment', e)
+        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.
@@ -262,24 +285,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
@@ -309,41 +331,46 @@ 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
+          # needs else branch coverage
+          if segment && segment.is_a?(Transaction::AbstractSegment) # rubocop:disable Style/SafeNavigation
+            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,
@@ -354,12 +381,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
@@ -385,13 +411,41 @@ 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(*args, segment_name:, 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
+            begin
+              if current_txn
+                NewRelic::Agent::Tracer.state.current_transaction = current_txn
+                current_txn.async = true
+                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)
+              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
@@ -408,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
@@ -416,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
@@ -426,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
@@ -436,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?
@@ -456,7 +510,5 @@ module NewRelic
         attr_accessor :sql_sampler_transaction_data
       end
     end
-
-    TransactionState = Tracer
   end
 end