newrelic_rpm 8.2.0 → 8.3.0

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

@@ -19,7 +19,7 @@ module NewRelic
         def instrument_save_methods
           ::ActiveRecord::Base.class_eval do
             alias_method :save_without_newrelic, :save
-            
+
             def save(*args, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
                 save_without_newrelic(*args, &blk)
@@ -45,7 +45,7 @@ module NewRelic
                 update_all_without_newrelic(*args, &blk)
               end
             end
-            
+
             alias_method :delete_all_without_newrelic, :delete_all
 
             if RUBY_VERSION < "2.7.0"
@@ -70,7 +70,6 @@ module NewRelic
               end
             end
 
-
             alias_method :calculate_without_newrelic, :calculate
 
             def calculate(*args, &blk)
@@ -79,7 +78,6 @@ module NewRelic
               end
             end
 
-
             if method_defined?(:pluck)
               alias_method :pluck_without_newrelic, :pluck
 
@@ -94,12 +92,12 @@ module NewRelic
         end
 
         ACTIVE_RECORD = "ActiveRecord".freeze
-        OTHER         = "other".freeze
+        OTHER = "other".freeze
 
         def product_operation_collection_for name, sql, adapter_name
-          product   = map_product(adapter_name)
-          splits    = split_name(name)
-          model     = model_from_splits(splits)
+          product = map_product(adapter_name)
+          splits = split_name(name)
+          model = model_from_splits(splits)
           operation = operation_from_splits(splits, sql)
           NewRelic::Agent::Datastores::MetricHelper.product_operation_collection_for product, operation, model, ACTIVE_RECORD
         end
@@ -118,8 +116,6 @@ module NewRelic
         def model_from_splits(splits)
           if splits.length == 2
             splits.first
-          else
-            nil
           end
         end
 
@@ -135,16 +131,16 @@ module NewRelic
         # known operations coming in. Anything not matching the list is fine,
         # it just needs to get downcased directly for use.
         OPERATION_NAMES = {
-          'Find'    => 'find',
-          'Load'    => 'find',
-          'Count'   => 'find',
-          'Exists'  => 'find',
-          'Create'  => 'create',
+          'Find' => 'find',
+          'Load' => 'find',
+          'Count' => 'find',
+          'Exists' => 'find',
+          'Create' => 'create',
           'Columns' => 'columns',
           'Indexes' => 'indexes',
           'Destroy' => 'destroy',
-          'Update'  => 'update',
-          'Save'    => 'save'
+          'Update' => 'update',
+          'Save' => 'save'
         }.freeze
 
         def map_operation(raw_operation)
@@ -155,41 +151,41 @@ module NewRelic
         end
 
         PRODUCT_NAMES = {
-          "mysql"      => "MySQL",
-          "mysql2"     => "MySQL",
+          "mysql" => "MySQL",
+          "mysql2" => "MySQL",
 
           "postgresql" => "Postgres",
 
-          "sqlite3"    => "SQLite",
+          "sqlite3" => "SQLite",
 
           # https://rubygems.org/gems/activerecord-jdbcpostgresql-adapter
-          "jdbcmysql"  => "MySQL",
+          "jdbcmysql" => "MySQL",
 
           # https://rubygems.org/gems/activerecord-jdbcpostgresql-adapter
           "jdbcpostgresql" => "Postgres",
-          
+
           # https://rubygems.org/gems/activerecord-postgis-adapter
-          "postgis"    => "Postgres",
+          "postgis" => "Postgres",
 
           # https://rubygems.org/gems/activerecord-jdbcsqlite3-adapter
-          "jdbcsqlite3"    => "SQLite",
+          "jdbcsqlite3" => "SQLite",
 
           # https://rubygems.org/gems/activerecord-jdbcderby-adapter
-          "derby"      => "Derby",
-          "jdbcderby"  => "Derby",
+          "derby" => "Derby",
+          "jdbcderby" => "Derby",
 
           # https://rubygems.org/gems/activerecord-jdbc-adapter
-          "jdbc"       => "JDBC",
+          "jdbc" => "JDBC",
 
           # https://rubygems.org/gems/activerecord-jdbcmssql-adapter
-          "jdbcmssql"  => "MSSQL",
-          "mssql"      => "MSSQL",
+          "jdbcmssql" => "MSSQL",
+          "mssql" => "MSSQL",
 
           # https://rubygems.org/gems/activerecord-sqlserver-adapter
-          "sqlserver"  => "MSSQL",
+          "sqlserver" => "MSSQL",
 
           # https://rubygems.org/gems/activerecord-odbc-adapter
-          "odbc"       => "ODBC",
+          "odbc" => "ODBC",
 
           # https://rubygems.org/gems/activerecord-oracle_enhanced-adapter
           "oracle_enhanced" => "Oracle"
@@ -199,24 +195,24 @@ module NewRelic
 
         def map_product(adapter_name)
           PRODUCT_NAMES.fetch(adapter_name,
-                              ACTIVE_RECORD_DEFAULT_PRODUCT_NAME)
+            ACTIVE_RECORD_DEFAULT_PRODUCT_NAME)
         end
 
         module InstanceIdentification
           extend self
 
           PRODUCT_SYMBOLS = {
-            "mysql"      => :mysql,
-            "mysql2"     => :mysql,
-            "jdbcmysql"  => :mysql,
+            "mysql" => :mysql,
+            "mysql2" => :mysql,
+            "jdbcmysql" => :mysql,
 
-            "postgresql"     => :postgres,
+            "postgresql" => :postgres,
             "jdbcpostgresql" => :postgres,
-            "postgis"        => :postgres
+            "postgis" => :postgres
           }.freeze
 
           DATASTORE_DEFAULT_PORTS = {
-            :mysql    => "3306",
+            :mysql => "3306",
             :postgres => "5432"
           }.freeze
 
@@ -228,10 +224,10 @@ module NewRelic
           def host(config)
             return UNKNOWN unless config
 
-            configured_value  = config[:host]
+            configured_value = config[:host]
             adapter = PRODUCT_SYMBOLS[config[:adapter]]
             if configured_value.nil? ||
-              postgres_unix_domain_socket_case?(configured_value, adapter)
+                postgres_unix_domain_socket_case?(configured_value, adapter)
 
               LOCALHOST
             elsif configured_value.empty?
@@ -239,7 +235,6 @@ module NewRelic
             else
               configured_value
             end
-
           rescue => e
             NewRelic::Agent.logger.debug "Failed to retrieve ActiveRecord host: #{e}"
             UNKNOWN
@@ -260,7 +255,6 @@ module NewRelic
             else
               UNKNOWN
             end
-
           rescue => e
             NewRelic::Agent.logger.debug "Failed to retrieve ActiveRecord port_path_or_id: #{e}"
             UNKNOWN

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

@@ -5,7 +5,6 @@
 require 'new_relic/agent/instrumentation/active_record_subscriber'
 require 'new_relic/agent/instrumentation/active_record_prepend'
 
-
 # Provides a way to send :connection through ActiveSupport notifications to avoid
 # looping through connection handlers to locate a connection by connection_id
 # This is not needed in Rails 6+: https://github.com/rails/rails/pull/34602
@@ -20,12 +19,13 @@ module NewRelic
           def log(sql, name = "SQL", binds = [], statement_name = nil)
             @instrumenter.instrument(
               SQL_ACTIVE_RECORD,
-              :sql            => sql,
-              :name           => name,
-              :connection_id  => object_id,
-              :connection     => self,
+              :sql => sql,
+              :name => name,
+              :connection_id => object_id,
+              :connection => self,
               :statement_name => statement_name,
-              :binds          => binds) { yield }
+              :binds => binds
+            ) { yield }
           rescue => e
             # The translate_exception_class method got introduced in 4.1
             if ::ActiveRecord::VERSION::MINOR == 0
@@ -41,13 +41,14 @@ module NewRelic
           def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
             @instrumenter.instrument(
               SQL_ACTIVE_RECORD,
-              sql:               sql,
-              name:              name,
-              binds:             binds,
+              sql: sql,
+              name: name,
+              binds: binds,
               type_casted_binds: type_casted_binds,
-              statement_name:    statement_name,
-              connection_id:     object_id,
-              connection:        self) { yield }
+              statement_name: statement_name,
+              connection_id: object_id,
+              connection: self
+            ) { yield }
           rescue => e
             raise translate_exception_class(e, sql)
           end
@@ -58,17 +59,18 @@ module NewRelic
           def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil) # :doc:
             @instrumenter.instrument(
               SQL_ACTIVE_RECORD,
-              sql:               sql,
-              name:              name,
-              binds:             binds,
+              sql: sql,
+              name: name,
+              binds: binds,
               type_casted_binds: type_casted_binds,
-              statement_name:    statement_name,
-              connection_id:     object_id,
-              connection:        self) do
-                @lock.synchronize do
-                  yield
-                end
+              statement_name: statement_name,
+              connection_id: object_id,
+              connection: self
+            ) do
+              @lock.synchronize do
+                yield
               end
+            end
           rescue => e
             raise translate_exception_class(e, sql)
           end
@@ -104,8 +106,9 @@ DependencyDetection.defer do
   executes do
     ActiveSupport.on_load(:active_record) do
       ::NewRelic::Agent::PrependSupportability.record_metrics_for(
-          ::ActiveRecord::Base,
-          ::ActiveRecord::Relation)
+        ::ActiveRecord::Base,
+        ::ActiveRecord::Relation
+      )
 
       # Default to .prepending, unless the ActiveRecord version is <=4
       # **AND** the :prepend_active_record_instrumentation config is false
@@ -113,9 +116,9 @@ DependencyDetection.defer do
           || ::NewRelic::Agent.config[:prepend_active_record_instrumentation]
 
         ::ActiveRecord::Base.send(:prepend,
-            ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions)
+          ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions)
         ::ActiveRecord::Relation.send(:prepend,
-            ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions)
+          ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions)
       else
         ::NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_additional_methods
       end

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

@@ -11,13 +11,13 @@ module NewRelic
         ACTIVE_RECORD = 'ActiveRecord'.freeze
 
         module BaseExtensions
-
           if RUBY_VERSION < "2.7.0"
             def save(*args, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
                 super
               end
             end
+
             def save!(*args, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
                 super
@@ -30,11 +30,12 @@ module NewRelic
                 super
               end
             end
+
             def save!(*args, **kwargs, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
                 super
               end
-            end  
+            end
 
           end
         end
@@ -58,7 +59,6 @@ module NewRelic
               end
             end
           end
-
         end
 
         module RelationExtensions

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

@@ -43,7 +43,7 @@ module NewRelic
           end
         end
 
-        def start(name, id, payload) #THREAD_LOCAL_ACCESS
+        def start(name, id, payload) # THREAD_LOCAL_ACCESS
           return if cached?(payload)
           return unless NewRelic::Agent.tl_is_execution_traced?
 
@@ -54,7 +54,7 @@ module NewRelic
           log_notification_error(e, name, 'start')
         end
 
-        def finish(name, id, payload) #THREAD_LOCAL_ACCESS
+        def finish(name, id, payload) # THREAD_LOCAL_ACCESS
           return if cached?(payload)
           return unless state.is_execution_traced?
 
@@ -64,7 +64,6 @@ module NewRelic
             end
             segment.finish
           end
-
         rescue => e
           log_notification_error(e, name, 'finish')
         end
@@ -72,12 +71,12 @@ module NewRelic
         def get_explain_plan(statement)
           connection = NewRelic::Agent::Database.get_connection(statement.config) do
             ::ActiveRecord::Base.send("#{statement.config[:adapter]}_connection",
-                                      statement.config)
+              statement.config)
           end
           if connection && connection.respond_to?(:exec_query)
             return connection.exec_query("EXPLAIN #{statement.sql}",
-                                         "Explain #{statement.name}",
-                                         statement.binds)
+              "Explain #{statement.name}",
+              statement.binds)
           end
         rescue => e
           NewRelic::Agent.logger.debug "Couldn't fetch the explain plan for #{statement} due to #{e}"

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

@@ -8,17 +8,16 @@ module NewRelic
   module Instrumentation
     module ActsAsSolrInstrumentation
       module ParserMethodsInstrumentation
-
-          def parse_query_with_newrelic(*args)
-            self.class.trace_execution_scoped(["SolrClient/ActsAsSolr/query"]) do
-              begin
-                parse_query_without_newrelic(*args)
-              ensure
-                return unless txn = ::NewRelic::Agent::Tracer.current_transaction
-                txn.current_segment.params[:statement] = ::NewRelic::Agent::Database.truncate_query(args.first.inspect) rescue nil
-              end
+        def parse_query_with_newrelic(*args)
+          self.class.trace_execution_scoped(["SolrClient/ActsAsSolr/query"]) do
+            begin
+              parse_query_without_newrelic(*args)
+            ensure
+              return unless txn = ::NewRelic::Agent::Tracer.current_transaction
+              txn.current_segment.params[:statement] = ::NewRelic::Agent::Database.truncate_query(args.first.inspect) rescue nil
             end
           end
+        end
       end
     end
   end

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

@@ -42,4 +42,4 @@ module NewRelic::Agent::Instrumentation
       end
     end
   end
-end
+end

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

@@ -12,7 +12,7 @@ module NewRelic
         LIBRARY = 'RabbitMQ'
         DEFAULT_NAME = 'Default'
         DEFAULT_TYPE = :direct
-        SLASH   = '/'
+        SLASH = '/'
 
         def exchange_name name
           name.empty? ? DEFAULT_NAME : name
@@ -74,11 +74,11 @@ module NewRelic
 
             begin
               exch_name, exch_type = if delivery_info
-                [ exchange_name(delivery_info.exchange),
-                  exchange_type(delivery_info, channel) ]
+                [exchange_name(delivery_info.exchange),
+                  exchange_type(delivery_info, channel)]
               else
-                [ exchange_name(NewRelic::EMPTY_STR),
-                  exchange_type({}, channel) ]
+                [exchange_name(NewRelic::EMPTY_STR),
+                  exchange_type({}, channel)]
               end
 
               segment = NewRelic::Agent::Messaging.start_amqp_consume_segment(
@@ -139,12 +139,11 @@ module NewRelic
               delivery_info: delivery_info,
               message_properties: message_properties,
               exchange_type: exchange_type(delivery_info, channel),
-              queue_name: queue_name) do
-
+              queue_name: queue_name
+            ) do
               yield
             end
           end
-
         end
       end
     end

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

@@ -22,7 +22,6 @@ module NewRelic
       # @api public
       #
       module ControllerInstrumentation
-
         def self.included(clazz) # :nodoc:
           clazz.extend(ClassMethods)
         end
@@ -30,7 +29,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 +39,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 = {}.freeze
 
         # @api public
         module ClassMethods
@@ -54,31 +57,32 @@ 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)
+            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
@@ -158,7 +162,7 @@ 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:
@@ -202,54 +206,50 @@ 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 = {})
             "#{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)
@@ -266,9 +266,9 @@ 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
@@ -345,7 +345,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)
@@ -363,8 +363,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(
@@ -379,7 +379,6 @@ module NewRelic
               NewRelic::Agent.notice_error(e)
               raise
             end
-
           ensure
             finishable.finish if finishable
           end
@@ -434,7 +433,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]
@@ -457,7 +456,8 @@ module NewRelic
           NewRelic::Agent::Instrumentation::IgnoreActions.is_filtered?(
             key,
             self.class,
-            name)
+            name
+          )
         end
 
         def detect_queue_start_time(request)