newrelic_rpm 6.15.0 → 8.13.1

data/lib/new_relic/agent/instrumentation/bunny/instrumentation.rb

@@ -0,0 +1,150 @@
+# 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 Instrumentation
+      module Bunny
+        module_function
+
+        LIBRARY = 'RabbitMQ'
+        DEFAULT_NAME = 'Default'
+        DEFAULT_TYPE = :direct
+        SLASH = '/'
+
+        def exchange_name(name)
+          name.empty? ? DEFAULT_NAME : name
+        end
+
+        def exchange_type(delivery_info, channel)
+          if di_exchange = delivery_info[:exchange]
+            return DEFAULT_TYPE if di_exchange.empty?
+            return channel.exchanges[delivery_info[:exchange]].type if channel.exchanges[di_exchange]
+          end
+        end
+
+        module Exchange
+          include Bunny
+
+          def publish_with_tracing(payload, opts = {})
+            begin
+              destination = exchange_name(name)
+
+              tracing_enabled =
+                NewRelic::Agent::CrossAppTracing.cross_app_enabled? ||
+                NewRelic::Agent.config[:'distributed_tracing.enabled']
+              opts[:headers] ||= {} if tracing_enabled
+
+              segment = NewRelic::Agent::Messaging.start_amqp_publish_segment(
+                library: LIBRARY,
+                destination_name: destination,
+                headers: opts[:headers],
+                routing_key: opts[:routing_key] || opts[:key],
+                reply_to: opts[:reply_to],
+                correlation_id: opts[:correlation_id],
+                exchange_type: type
+              )
+            rescue => e
+              NewRelic::Agent.logger.error("Error starting message broker segment in Bunny::Exchange#publish", e)
+              yield
+            else
+              NewRelic::Agent::Tracer.capture_segment_error(segment) do
+                yield
+              end
+            ensure
+              segment.finish if segment
+            end
+          end
+        end
+
+        module Queue
+          include Bunny
+
+          def pop_with_tracing
+            bunny_error, delivery_info, message_properties, _payload = nil, nil, nil, nil
+            begin
+              t0 = Process.clock_gettime(Process::CLOCK_REALTIME)
+              msg = yield
+              delivery_info, message_properties, _payload = msg
+            rescue StandardError => error
+              bunny_error = error
+            end
+
+            begin
+              exch_name, exch_type = if delivery_info
+                [exchange_name(delivery_info.exchange),
+                  exchange_type(delivery_info, channel)]
+              else
+                [exchange_name(NewRelic::EMPTY_STR),
+                  exchange_type({}, channel)]
+              end
+
+              segment = NewRelic::Agent::Messaging.start_amqp_consume_segment(
+                library: LIBRARY,
+                destination_name: exch_name,
+                delivery_info: (delivery_info || {}),
+                message_properties: (message_properties || {headers: {}}),
+                exchange_type: exch_type,
+                queue_name: name,
+                start_time: t0
+              )
+            rescue => e
+              NewRelic::Agent.logger.error("Error starting message broker segment in Bunny::Queue#pop", e)
+            else
+              if bunny_error
+                segment.notice_error(bunny_error)
+                raise bunny_error
+              end
+            ensure
+              segment.finish if segment
+            end
+
+            msg
+          end
+
+          def purge_with_tracing
+            begin
+              type = server_named? ? :temporary_queue : :queue
+              segment = NewRelic::Agent::Tracer.start_message_broker_segment(
+                action: :purge,
+                library: LIBRARY,
+                destination_type: type,
+                destination_name: name
+              )
+            rescue => e
+              NewRelic::Agent.logger.error("Error starting message broker segment in Bunny::Queue#purge", e)
+              yield
+            else
+              NewRelic::Agent::Tracer.capture_segment_error(segment) do
+                yield
+              end
+            ensure
+              segment.finish if segment
+            end
+          end
+        end
+
+        module Consumer
+          include Bunny
+
+          def call_with_tracing(*args)
+            delivery_info, message_properties, _ = args
+            queue_name = queue.respond_to?(:name) ? queue.name : queue
+
+            NewRelic::Agent::Messaging.wrap_amqp_consume_transaction(
+              library: LIBRARY,
+              destination_name: exchange_name(delivery_info.exchange),
+              delivery_info: delivery_info,
+              message_properties: message_properties,
+              exchange_type: exchange_type(delivery_info, channel),
+              queue_name: queue_name
+            ) do
+              yield
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/bunny/prepend.rb

@@ -0,0 +1,35 @@
+# 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::Agent::Instrumentation
+  module Bunny::Prepend
+    module Exchange
+      include NewRelic::Agent::Instrumentation::Bunny::Exchange
+
+      def publish(payload, opts = {})
+        publish_with_tracing(payload, opts) { super }
+      end
+    end
+
+    module Queue
+      include NewRelic::Agent::Instrumentation::Bunny::Queue
+
+      def pop(opts = {:manual_ack => false}, &block)
+        pop_with_tracing { super }
+      end
+
+      def purge(*args)
+        purge_with_tracing { super }
+      end
+    end
+
+    module Consumer
+      include NewRelic::Agent::Instrumentation::Bunny::Consumer
+
+      def call(*args)
+        call_with_tracing(*args) { super }
+      end
+    end
+  end
+end

data/lib/new_relic/agent/instrumentation/bunny.rb

@@ -1,8 +1,11 @@
-# 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_relative 'bunny/instrumentation'
+require_relative 'bunny/chain'
+require_relative 'bunny/prepend'
+
 DependencyDetection.defer do
   named :bunny
 
@@ -11,165 +14,19 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing Bunny instrumentation'
+    ::NewRelic::Agent.logger.info('Installing Bunny instrumentation')
     require 'new_relic/agent/distributed_tracing/cross_app_tracing'
     require 'new_relic/agent/messaging'
     require 'new_relic/agent/transaction/message_broker_segment'
   end
 
   executes do
-    module Bunny
-      class Exchange
-        alias_method :publish_without_new_relic, :publish
-
-        def publish payload, opts = {}
-          begin
-            destination = NewRelic::Agent::Instrumentation::Bunny.exchange_name(name)
-
-            tracing_enabled =
-              NewRelic::Agent::CrossAppTracing.cross_app_enabled? ||
-              NewRelic::Agent.config[:'distributed_tracing.enabled']
-            opts[:headers] ||= {} if tracing_enabled
-
-            segment = NewRelic::Agent::Messaging.start_amqp_publish_segment(
-              library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
-              destination_name: destination,
-              headers: opts[:headers],
-              routing_key: opts[:routing_key] || opts[:key],
-              reply_to: opts[:reply_to],
-              correlation_id: opts[:correlation_id],
-              exchange_type: type
-            )
-          rescue => e
-            NewRelic::Agent.logger.error "Error starting message broker segment in Bunny::Exchange#publish", e
-            publish_without_new_relic payload, opts
-          else
-            NewRelic::Agent::Tracer.capture_segment_error segment do
-              publish_without_new_relic payload, opts
-            end
-          ensure
-            segment.finish if segment
-          end
-        end
-      end
-
-      class Queue
-        alias_method :pop_without_new_relic, :pop
-
-        def pop(opts = {:manual_ack => false}, &block)
-          bunny_error, delivery_info, message_properties, _payload = nil, nil, nil, nil
-          begin
-            t0 = Time.now
-            msg = pop_without_new_relic opts, &block
-            delivery_info, message_properties, _payload = msg
-          rescue StandardError => error
-            bunny_error = error
-          end
-
-          begin
-            exchange_name, exchange_type = if delivery_info
-              [ NewRelic::Agent::Instrumentation::Bunny.exchange_name(delivery_info.exchange),
-                NewRelic::Agent::Instrumentation::Bunny.exchange_type(delivery_info, channel) ]
-            else
-              [ NewRelic::Agent::Instrumentation::Bunny.exchange_name(NewRelic::EMPTY_STR),
-                NewRelic::Agent::Instrumentation::Bunny.exchange_type({}, channel) ]
-            end
-
-            segment = NewRelic::Agent::Messaging.start_amqp_consume_segment(
-              library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
-              destination_name: exchange_name,
-              delivery_info: (delivery_info || {}),
-              message_properties: (message_properties || {headers: {}}),
-              exchange_type: exchange_type,
-              queue_name: name,
-              start_time: t0
-            )
-          rescue => e
-            NewRelic::Agent.logger.error "Error starting message broker segment in Bunny::Queue#pop", e
-          else
-            if bunny_error
-              segment.notice_error bunny_error
-              raise bunny_error
-            end
-          ensure
-            segment.finish if segment
-          end
-
-          msg
-        end
-
-        alias_method :purge_without_new_relic, :purge
-
-        def purge *args
-          begin
-            type = server_named? ? :temporary_queue : :queue
-            segment = NewRelic::Agent::Tracer.start_message_broker_segment(
-              action: :purge,
-              library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
-              destination_type: type,
-              destination_name: name
-            )
-          rescue => e
-            NewRelic::Agent.logger.error "Error starting message broker segment in Bunny::Queue#purge", e
-            purge_without_new_relic(*args)
-          else
-            NewRelic::Agent::Tracer.capture_segment_error segment do
-              purge_without_new_relic(*args)
-            end
-          ensure
-            segment.finish if segment
-          end
-        end
-
-      end
-
-      class Consumer
-        alias_method :call_without_new_relic, :call
-
-        def call *args
-          delivery_info, message_properties, _ = args
-          queue_name = queue.respond_to?(:name) ? queue.name : queue
-
-          NewRelic::Agent::Messaging.wrap_amqp_consume_transaction(
-            library: NewRelic::Agent::Instrumentation::Bunny::LIBRARY,
-            destination_name: NewRelic::Agent::Instrumentation::Bunny.exchange_name(delivery_info.exchange),
-            delivery_info: delivery_info,
-            message_properties: message_properties,
-            exchange_type: NewRelic::Agent::Instrumentation::Bunny.exchange_type(delivery_info, channel),
-            queue_name: queue_name) do
-
-            call_without_new_relic(*args)
-          end
-        end
-
-      end
-    end
-  end
-end
-
-module NewRelic
-  module Agent
-    module Instrumentation
-      module Bunny
-        LIBRARY = 'RabbitMQ'
-        DEFAULT_NAME = 'Default'
-        DEFAULT_TYPE = :direct
-
-        SLASH   = '/'
-
-        class << self
-          def exchange_name name
-            name.empty? ? DEFAULT_NAME : name
-          end
-
-          def exchange_type delivery_info, channel
-            if di_exchange = delivery_info[:exchange]
-              return DEFAULT_TYPE if di_exchange.empty?
-              return channel.exchanges[delivery_info[:exchange]].type if channel.exchanges[di_exchange]
-            end
-          end
-        end
-      end
+    if use_prepend?
+      prepend_instrument ::Bunny::Exchange, ::NewRelic::Agent::Instrumentation::Bunny::Prepend::Exchange
+      prepend_instrument ::Bunny::Queue, ::NewRelic::Agent::Instrumentation::Bunny::Prepend::Queue
+      prepend_instrument ::Bunny::Consumer, ::NewRelic::Agent::Instrumentation::Bunny::Prepend::Consumer
+    else
+      chain_instrument NewRelic::Agent::Instrumentation::Bunny
     end
   end
 end

data/lib/new_relic/agent/instrumentation/controller_instrumentation.rb

@@ -1,10 +1,11 @@
-# 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/transaction'
 require 'new_relic/agent/instrumentation/queue_time'
 require 'new_relic/agent/instrumentation/ignore_actions'
+
 module NewRelic
   module Agent
     # @api public
@@ -22,7 +23,6 @@ module NewRelic
       # @api public
       #
       module ControllerInstrumentation
-
         def self.included(clazz) # :nodoc:
           clazz.extend(ClassMethods)
         end
@@ -30,7 +30,9 @@ module NewRelic
         # This module is for importing stubs when the agent is disabled
         module ClassMethodsShim # :nodoc:
           def newrelic_ignore(*args); end
+
           def newrelic_ignore_apdex(*args); end
+
           def newrelic_ignore_enduser(*args); end
         end
 
@@ -38,14 +40,16 @@ module NewRelic
           def self.included(clazz)
             clazz.extend(ClassMethodsShim)
           end
+
           def new_relic_trace_controller_action(*args); yield; end
+
           def perform_action_with_newrelic_trace(*args); yield; end
         end
 
-        NR_DO_NOT_TRACE_KEY   = :'@do_not_trace'
-        NR_IGNORE_APDEX_KEY   = :'@ignore_apdex'
+        NR_DO_NOT_TRACE_KEY = :'@do_not_trace'
+        NR_IGNORE_APDEX_KEY = :'@ignore_apdex'
         NR_IGNORE_ENDUSER_KEY = :'@ignore_enduser'
-        NR_DEFAULT_OPTIONS    = {}.freeze
+        NR_DEFAULT_OPTIONS = NewRelic::EMPTY_HASH
 
         # @api public
         module ClassMethods
@@ -54,32 +58,33 @@ module NewRelic
           #
           # @api public
           #
-          def newrelic_ignore(specifiers={})
+          def newrelic_ignore(specifiers = {})
             NewRelic::Agent.record_api_supportability_metric(:newrelic_ignore)
             newrelic_ignore_aspect(NR_DO_NOT_TRACE_KEY, specifiers)
           end
+
           # Have NewRelic omit apdex measurements on the given actions.  Typically used for
           # actions that are not user facing or that skew your overall apdex measurement.
           # Accepts :except and :only options, as with #newrelic_ignore.
           #
           # @api public
           #
-          def newrelic_ignore_apdex(specifiers={})
+          def newrelic_ignore_apdex(specifiers = {})
             NewRelic::Agent.record_api_supportability_metric(:newrelic_ignore_apdex)
             newrelic_ignore_aspect(NR_IGNORE_APDEX_KEY, specifiers)
           end
 
           # @api public
-          def newrelic_ignore_enduser(specifiers={})
+          def newrelic_ignore_enduser(specifiers = {})
             NewRelic::Agent.record_api_supportability_metric(:newrelic_ignore_enduser)
             newrelic_ignore_aspect(NR_IGNORE_ENDUSER_KEY, specifiers)
           end
 
-          def newrelic_ignore_aspect(property, specifiers={}) # :nodoc:
+          def newrelic_ignore_aspect(property, specifiers = {}) # :nodoc:
             if specifiers.empty?
-              self.newrelic_write_attr property, true
-            elsif ! (Hash === specifiers)
-              ::NewRelic::Agent.logger.error "newrelic_#{property} takes an optional hash with :only and :except lists of actions (illegal argument type '#{specifiers.class}')"
+              self.newrelic_write_attr(property, true)
+            elsif !(Hash === specifiers)
+              ::NewRelic::Agent.logger.error("newrelic_#{property} takes an optional hash with :only and :except lists of actions (illegal argument type '#{specifiers.class}')")
             else
               # symbolize the incoming values
               specifiers = specifiers.inject({}) do |memo, (key, values)|
@@ -90,7 +95,7 @@ module NewRelic
                 end
                 memo
               end
-              self.newrelic_write_attr property, specifiers
+              self.newrelic_write_attr(property, specifiers)
             end
           end
 
@@ -158,13 +163,9 @@ module NewRelic
           #
           # @api public
           #
-          def add_transaction_tracer(method, options={})
+          def add_transaction_tracer(method, options = {})
             NewRelic::Agent.record_api_supportability_metric(:add_transaction_tracer)
 
-            # The metric path:
-            options[:name] ||= method.to_s
-
-            argument_list = generate_argument_list(options)
             traced_method, punctuation = parse_punctuation(method)
             with_method_name, without_method_name = build_method_names(traced_method, punctuation)
 
@@ -173,20 +174,27 @@ module NewRelic
               return
             end
 
-            class_eval <<-EOC
+            # The metric path:
+            options[:name] ||= method.to_s
+
+            code_info = NewRelic::Agent::MethodTracerHelpers.code_information(self, method)
+            argument_list = generate_argument_list(options.merge(code_info))
+
+            class_eval(<<-EOC)
               def #{with_method_name}(*args, &block)
                 perform_action_with_newrelic_trace(#{argument_list.join(',')}) do
                   #{without_method_name}(*args, &block)
                  end
               end
+              ruby2_keywords(:#{with_method_name}) if respond_to?(:ruby2_keywords, true)
             EOC
 
-            visibility = NewRelic::Helper.instance_method_visibility self, method
+            visibility = NewRelic::Helper.instance_method_visibility(self, method)
 
-            alias_method without_method_name, method.to_s
-            alias_method method.to_s, with_method_name
-            send visibility, method
-            send visibility, with_method_name
+            alias_method(without_method_name, method.to_s)
+            alias_method(method.to_s, with_method_name)
+            send(visibility, method)
+            send(visibility, with_method_name)
             ::NewRelic::Agent.logger.debug("Traced transaction: class = #{self.name}, method = #{method.to_s}, options = #{options.inspect}")
           end
 
@@ -201,54 +209,52 @@ module NewRelic
               elsif key == :params
                 value.to_s
               else
-                %Q["#{value.to_s}"]
+                %Q("#{value.to_s}")
               end
 
-              %Q[:#{key} => #{value}]
+              %Q(:#{key} => #{value})
             end
           end
 
           def build_method_names(traced_method, punctuation)
-            [ "#{traced_method.to_s}_with_newrelic_transaction_trace#{punctuation}",
-              "#{traced_method.to_s}_without_newrelic_transaction_trace#{punctuation}" ]
+            ["#{traced_method.to_s}_with_newrelic_transaction_trace#{punctuation}",
+              "#{traced_method.to_s}_without_newrelic_transaction_trace#{punctuation}"]
           end
 
           def already_added_transaction_tracer?(target, with_method_name)
-            if NewRelic::Helper.instance_methods_include?(target, with_method_name)
-              true
-            else
-              false
-            end
+            NewRelic::Helper.instance_methods_include?(target, with_method_name)
           end
         end
 
         # @!parse extend ClassMethods
 
         class TransactionNamer
-          def self.name_for(txn, traced_obj, category, options={})
+          def self.name_for(txn, traced_obj, category, options = {})
+            return options[:transaction_name] if options[:transaction_name]
+
             "#{prefix_for_category(txn, category)}#{path_name(traced_obj, options)}"
           end
 
           def self.prefix_for_category(txn, category = nil)
             category ||= (txn && txn.category)
             case category
-            when :controller    then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
-            when :web           then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
-            when :task          then ::NewRelic::Agent::Transaction::TASK_PREFIX
-            when :background    then ::NewRelic::Agent::Transaction::TASK_PREFIX
-            when :rack          then ::NewRelic::Agent::Transaction::RACK_PREFIX
-            when :uri           then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
-            when :sinatra       then ::NewRelic::Agent::Transaction::SINATRA_PREFIX
-            when :middleware    then ::NewRelic::Agent::Transaction::MIDDLEWARE_PREFIX
-            when :grape         then ::NewRelic::Agent::Transaction::GRAPE_PREFIX
-            when :rake          then ::NewRelic::Agent::Transaction::RAKE_PREFIX
-            when :action_cable  then ::NewRelic::Agent::Transaction::ACTION_CABLE_PREFIX
-            when :message       then ::NewRelic::Agent::Transaction::MESSAGE_PREFIX
+            when :controller then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
+            when :web then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
+            when :task then ::NewRelic::Agent::Transaction::TASK_PREFIX
+            when :background then ::NewRelic::Agent::Transaction::TASK_PREFIX
+            when :rack then ::NewRelic::Agent::Transaction::RACK_PREFIX
+            when :uri then ::NewRelic::Agent::Transaction::CONTROLLER_PREFIX
+            when :sinatra then ::NewRelic::Agent::Transaction::SINATRA_PREFIX
+            when :middleware then ::NewRelic::Agent::Transaction::MIDDLEWARE_PREFIX
+            when :grape then ::NewRelic::Agent::Transaction::GRAPE_PREFIX
+            when :rake then ::NewRelic::Agent::Transaction::RAKE_PREFIX
+            when :action_cable then ::NewRelic::Agent::Transaction::ACTION_CABLE_PREFIX
+            when :message then ::NewRelic::Agent::Transaction::MESSAGE_PREFIX
             else "#{category.to_s}/" # for internal use only
             end
           end
 
-          def self.path_name(traced_obj, options={})
+          def self.path_name(traced_obj, options = {})
             return options[:path] if options[:path]
 
             class_name = class_name(traced_obj, options)
@@ -265,9 +271,10 @@ module NewRelic
             end
           end
 
-          def self.class_name(traced_obj, options={})
+          def self.class_name(traced_obj, options = {})
             return options[:class_name] if options[:class_name]
-            if (traced_obj.is_a?(Class) || traced_obj.is_a?(Module))
+
+            if traced_obj.is_a?(Class) || traced_obj.is_a?(Module)
               traced_obj.name
             else
               traced_obj.class.name
@@ -276,7 +283,7 @@ module NewRelic
         end
 
         # Yield to the given block with NewRelic tracing.  Used by
-        # default instrumentation on controller actions in Rails and Merb.
+        # default instrumentation on controller actions in Rails.
         # But it can also be used in custom instrumentation of controller
         # methods and background tasks.
         #
@@ -344,7 +351,7 @@ module NewRelic
         #
         # @api public
         #
-        def perform_action_with_newrelic_trace(*args, &block) #THREAD_LOCAL_ACCESS
+        def perform_action_with_newrelic_trace(*args, &block) # THREAD_LOCAL_ACCESS
           NewRelic::Agent.record_api_supportability_metric(:perform_action_with_newrelic_trace)
           state = NewRelic::Agent::Tracer.state
           request = newrelic_request(args)
@@ -362,8 +369,8 @@ module NewRelic
           # the *args method signature to ensure backwards compatibility.
 
           trace_options = args.last.is_a?(Hash) ? args.last : NR_DEFAULT_OPTIONS
-          category      = trace_options[:category] || :controller
-          txn_options   = create_transaction_options(trace_options, category, state, queue_start_time)
+          category = trace_options[:category] || :controller
+          txn_options = create_transaction_options(trace_options, category, state, queue_start_time)
 
           begin
             finishable = Tracer.start_transaction_or_segment(
@@ -378,7 +385,6 @@ module NewRelic
               NewRelic::Agent.notice_error(e)
               raise
             end
-
           ensure
             finishable.finish if finishable
           end
@@ -410,14 +416,14 @@ module NewRelic
           end
         end
 
-        # overrideable method to determine whether to trace an action
+        # overridable method to determine whether to trace an action
         # or not - you may override this in your controller and supply
         # your own logic for ignoring transactions.
         def do_not_trace?
           _is_filtered?(NR_DO_NOT_TRACE_KEY)
         end
 
-        # overrideable method to determine whether to trace an action
+        # overridable method to determine whether to trace an action
         # for purposes of apdex measurement - you can use this to
         # ignore things like api calls or other fast non-user-facing
         # actions
@@ -433,7 +439,7 @@ module NewRelic
 
         def create_transaction_options(trace_options, category, state, queue_start_time)
           txn_options = {}
-          txn_options[:request]   = trace_options[:request]
+          txn_options[:request] = trace_options[:request]
           txn_options[:request] ||= request if respond_to?(:request) rescue nil
           # params should have been filtered before calling perform_action_with_newrelic_trace
           txn_options[:filtered_params] = trace_options[:params]
@@ -441,6 +447,9 @@ module NewRelic
           txn_options[:apdex_start_time] = queue_start_time
           txn_options[:ignore_apdex] = ignore_apdex?
           txn_options[:ignore_enduser] = ignore_enduser?
+          NewRelic::Agent::MethodTracerHelpers::SOURCE_CODE_INFORMATION_PARAMETERS.each do |parameter|
+            txn_options[parameter] = trace_options[parameter]
+          end
           txn_options
         end
 
@@ -456,7 +465,8 @@ module NewRelic
           NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
             key,
             self.class,
-            name)
+            name
+          )
         end
 
         def detect_queue_start_time(request)