newrelic_rpm 6.15.0 → 8.13.1

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

@@ -1,6 +1,7 @@
-# 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/instrumentation/notifications_subscriber'
 
 # Listen for ActiveSupport::Notifications events for ActionView render
@@ -9,8 +10,7 @@ module NewRelic
   module Agent
     module Instrumentation
       class ActionViewSubscriber < NotificationsSubscriber
-
-        def start(name, id, payload) #THREAD_LOCAL_ACCESS
+        def start(name, id, payload) # THREAD_LOCAL_ACCESS
           parent = segment_stack[id].last
           metric_name = format_metric_name(name, payload, parent)
 
@@ -18,7 +18,7 @@ module NewRelic
           if state.is_execution_traced? && recordable?(name, metric_name)
             event.finishable = Tracer.start_segment(name: metric_name)
           end
-          push_segment id, event
+          push_segment(id, event)
         rescue => e
           log_notification_error(e, name, 'start')
         end
@@ -26,7 +26,7 @@ module NewRelic
         def finish(name, id, payload)
           if segment = pop_segment(id)
             if exception = exception_object(payload)
-              segment.notice_error exception
+              segment.notice_error(exception)
             end
             segment.finish
           end
@@ -58,15 +58,15 @@ module NewRelic
               || metric_name == "View/#{::NewRelic::Agent::UNKNOWN_METRIC}/Partial"
         end
 
-        RENDER_TEMPLATE_EVENT_NAME   = 'render_template.action_view'.freeze
-        RENDER_PARTIAL_EVENT_NAME    = 'render_partial.action_view'.freeze
+        RENDER_TEMPLATE_EVENT_NAME = 'render_template.action_view'.freeze
+        RENDER_PARTIAL_EVENT_NAME = 'render_partial.action_view'.freeze
         RENDER_COLLECTION_EVENT_NAME = 'render_collection.action_view'.freeze
 
         def metric_action(name)
           case name
-          when /#{RENDER_TEMPLATE_EVENT_NAME}$/ then 'Rendering'
-          when RENDER_PARTIAL_EVENT_NAME        then 'Partial'
-          when RENDER_COLLECTION_EVENT_NAME     then 'Partial'
+          when /#{RENDER_TEMPLATE_EVENT_NAME}$/o then 'Rendering'
+          when RENDER_PARTIAL_EVENT_NAME then 'Partial'
+          when RENDER_COLLECTION_EVENT_NAME then 'Partial'
           end
         end
 
@@ -102,11 +102,10 @@ module NewRelic
           @finishable.finish if @finishable
         end
 
-        def notice_error error
-          @finishable.notice_error error if @finishable
+        def notice_error(error)
+          @finishable.notice_error(error) if @finishable
         end
       end
     end
-
   end
 end

data/lib/new_relic/agent/instrumentation/active_job.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 'new_relic/agent/prepend_supportability'
 
@@ -12,7 +12,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing ActiveJob instrumentation'
+    ::NewRelic::Agent.logger.info('Installing ActiveJob instrumentation')
 
     ActiveSupport.on_load(:active_job) do
       ::ActiveJob::Base.around_enqueue do |job, block|
@@ -44,12 +44,13 @@ module NewRelic
 
           # Don't nest transactions if we're already in a web transaction.
           # Probably inline processing the job if that happens, so just trace.
-          if    txn &&  txn.recording_web_transaction?
+          if txn && txn.recording_web_transaction?
             run_in_trace(job, block, :Consume)
           elsif txn && !txn.recording_web_transaction?
             ::NewRelic::Agent::Transaction.set_default_transaction_name(
               transaction_name_suffix_for_job(job),
-              transaction_category)
+              transaction_category
+            )
             block.call
           else
             run_in_transaction(job, block)
@@ -57,15 +58,21 @@ module NewRelic
         end
 
         def self.run_in_trace(job, block, event)
-          trace_execution_scoped("MessageBroker/#{adapter}/Queue/#{event}/Named/#{job.queue_name}") do
+          trace_execution_scoped("MessageBroker/#{adapter}/Queue/#{event}/Named/#{job.queue_name}",
+            code_information: code_information_for_job(job)) do
             block.call
           end
         end
 
         def self.run_in_transaction(job, block)
+          options = code_information_for_job(job)
+          options = {} if options.frozen? # the hash will be added to later
           ::NewRelic::Agent::Tracer.in_transaction(name: transaction_name_for_job(job),
-                                                   category: :other,
-                                                   &block)
+            category: :other, options: options, &block)
+        end
+
+        def self.code_information_for_job(job)
+          NewRelic::Agent::MethodTracerHelpers.code_information(job.class, :perform)
         end
 
         def self.transaction_category

data/lib/new_relic/agent/instrumentation/active_merchant.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
 
 DependencyDetection.defer do
   @name = :active_merchant
@@ -12,7 +12,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing ActiveMerchant instrumentation'
+    ::NewRelic::Agent.logger.info('Installing ActiveMerchant instrumentation')
   end
 
   executes do
@@ -24,14 +24,28 @@ DependencyDetection.defer do
       gateway.class_eval do
         implemented_methods = public_instance_methods(false).map(&:to_sym)
         gateway_name = self.name.split('::').last
-        [:authorize, :purchase, :credit, :void, :capture, :recurring, :store, :unstore, :update].each do |operation|
+        actions = [:authorize, :purchase, :credit, :void, :capture, :recurring, :store, :unstore, :update]
+        actions.each do |operation|
           if implemented_methods.include?(operation)
-            add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}/#{operation}"
-            add_method_tracer operation, "ActiveMerchant/gateway/#{gateway_name}", :push_scope => false
-            add_method_tracer operation, "ActiveMerchant/operation/#{operation}", :push_scope => false
+            add_method_tracer operation, [-> (*) { "ActiveMerchant/gateway/#{gateway_name}/#{operation}" },
+              -> (*) { "ActiveMerchant/gateway/#{gateway_name}" },
+              -> (*) { "ActiveMerchant/operation/#{operation}" }]
           end
         end
       end
     end
   end
+
+  executes do
+    next unless Gem::Version.new(ActiveMerchant::VERSION) < Gem::Version.new('1.65.0')
+
+    deprecation_msg = 'The Ruby Agent is dropping support for ActiveMerchant versions below 1.65.0 ' \
+      'in version 9.0.0. Please upgrade your ActiveMerchant version to continue receiving full support. ' \
+
+    ::NewRelic::Agent.logger.log_once(
+      :warn,
+      :deprecated_active_merchant_version,
+      deprecation_msg
+    )
+  end
 end

data/lib/new_relic/agent/instrumentation/active_record.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 'new_relic/agent/instrumentation/active_record_prepend'
 
@@ -11,7 +11,7 @@ module NewRelic
         EXPLAINER = lambda do |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?(:execute)
             return connection.execute("EXPLAIN #{statement.sql}")
@@ -21,8 +21,8 @@ module NewRelic
         def self.insert_instrumentation
           if defined?(::ActiveRecord::VERSION::MAJOR) && ::ActiveRecord::VERSION::MAJOR.to_i >= 3
             if ::NewRelic::Agent.config[:prepend_active_record_instrumentation]
-              ::ActiveRecord::Base.prepend ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions
-              ::ActiveRecord::Relation.prepend ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions
+              ::ActiveRecord::Base.prepend(::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions)
+              ::ActiveRecord::Relation.prepend(::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions)
             else
               ::NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_additional_methods
             end
@@ -36,9 +36,9 @@ module NewRelic
         def self.included(instrumented_class)
           instrumented_class.class_eval do
             unless instrumented_class.method_defined?(:log_without_newrelic_instrumentation)
-              alias_method :log_without_newrelic_instrumentation, :log
-              alias_method :log, :log_with_newrelic_instrumentation
-              protected :log
+              alias_method(:log_without_newrelic_instrumentation, :log)
+              alias_method(:log, :log_with_newrelic_instrumentation)
+              protected(:log)
             end
           end
         end
@@ -46,28 +46,29 @@ module NewRelic
         if RUBY_VERSION < "2.7.0"
           def log_with_newrelic_instrumentation(*args, &block)
             state = NewRelic::Agent::Tracer.state
-  
+
             if !state.is_execution_traced?
               return log_without_newrelic_instrumentation(*args, &block)
             end
-  
+
             sql, name, _ = args
-  
+
             product, operation, collection = ActiveRecordHelper.product_operation_collection_for(
               NewRelic::Helper.correctly_encoded(name),
               NewRelic::Helper.correctly_encoded(sql),
-              @config && @config[:adapter])
-  
+              @config && @config[:adapter]
+            )
+
             host = nil
             port_path_or_id = nil
             database = nil
-  
+
             if ActiveRecordHelper::InstanceIdentification.supported_adapter?(@config)
               host = ActiveRecordHelper::InstanceIdentification.host(@config)
               port_path_or_id = ActiveRecordHelper::InstanceIdentification.port_path_or_id(@config)
               database = @config && @config[:database]
             end
-  
+
             segment = NewRelic::Agent::Tracer.start_datastore_segment(
               product: product,
               operation: operation,
@@ -77,40 +78,41 @@ module NewRelic
               database_name: database
             )
             segment._notice_sql(sql, @config, EXPLAINER)
-  
+
             begin
-              NewRelic::Agent::Tracer.capture_segment_error segment do
+              NewRelic::Agent::Tracer.capture_segment_error(segment) do
                 log_without_newrelic_instrumentation(*args, &block)
               end
             ensure
               segment.finish if segment
             end
           end
-        else 
+        else
           def log_with_newrelic_instrumentation(*args, **kwargs, &block)
             state = NewRelic::Agent::Tracer.state
-  
+
             if !state.is_execution_traced?
               return log_without_newrelic_instrumentation(*args, **kwargs, &block)
             end
-  
+
             sql, name, _ = args
-  
+
             product, operation, collection = ActiveRecordHelper.product_operation_collection_for(
               NewRelic::Helper.correctly_encoded(name),
               NewRelic::Helper.correctly_encoded(sql),
-              @config && @config[:adapter])
-  
+              @config && @config[:adapter]
+            )
+
             host = nil
             port_path_or_id = nil
             database = nil
-  
+
             if ActiveRecordHelper::InstanceIdentification.supported_adapter?(@config)
               host = ActiveRecordHelper::InstanceIdentification.host(@config)
               port_path_or_id = ActiveRecordHelper::InstanceIdentification.port_path_or_id(@config)
               database = @config && @config[:database]
             end
-  
+
             segment = NewRelic::Agent::Tracer.start_datastore_segment(
               product: product,
               operation: operation,
@@ -120,9 +122,9 @@ module NewRelic
               database_name: database
             )
             segment._notice_sql(sql, @config, EXPLAINER)
-  
+
             begin
-              NewRelic::Agent::Tracer.capture_segment_error segment do
+              NewRelic::Agent::Tracer.capture_segment_error(segment) do
                 log_without_newrelic_instrumentation(*args, **kwargs, &block)
               end
             ensure
@@ -149,7 +151,7 @@ DependencyDetection.defer do
   end
 
   executes do
-    ::NewRelic::Agent.logger.info 'Installing ActiveRecord instrumentation'
+    ::NewRelic::Agent.logger.info('Installing ActiveRecord instrumentation')
   end
 
   executes do

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

@@ -1,8 +1,9 @@
-# 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/datastores/metric_helper'
+require 'new_relic/constants'
 
 module NewRelic
   module Agent
@@ -18,15 +19,15 @@ module NewRelic
 
         def instrument_save_methods
           ::ActiveRecord::Base.class_eval do
-            alias_method :save_without_newrelic, :save
-            
+            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)
               end
             end
 
-            alias_method :save_without_newrelic!, :save!
+            alias_method(:save_without_newrelic!, :save!)
 
             def save!(*args, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
@@ -38,15 +39,15 @@ module NewRelic
 
         def instrument_relation_methods
           ::ActiveRecord::Relation.class_eval do
-            alias_method :update_all_without_newrelic, :update_all
+            alias_method(:update_all_without_newrelic, :update_all)
 
             def update_all(*args, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
                 update_all_without_newrelic(*args, &blk)
               end
             end
-            
-            alias_method :delete_all_without_newrelic, :delete_all
+
+            alias_method(:delete_all_without_newrelic, :delete_all)
 
             if RUBY_VERSION < "2.7.0"
               def delete_all(*args, &blk)
@@ -62,7 +63,7 @@ module NewRelic
               end
             end
 
-            alias_method :destroy_all_without_newrelic, :destroy_all
+            alias_method(:destroy_all_without_newrelic, :destroy_all)
 
             def destroy_all(*args, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
@@ -70,8 +71,7 @@ module NewRelic
               end
             end
 
-
-            alias_method :calculate_without_newrelic, :calculate
+            alias_method(:calculate_without_newrelic, :calculate)
 
             def calculate(*args, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
@@ -79,9 +79,8 @@ module NewRelic
               end
             end
 
-
             if method_defined?(:pluck)
-              alias_method :pluck_without_newrelic, :pluck
+              alias_method(:pluck_without_newrelic, :pluck)
 
               def pluck(*args, &blk)
                 ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
@@ -94,32 +93,41 @@ module NewRelic
         end
 
         ACTIVE_RECORD = "ActiveRecord".freeze
-        OTHER         = "other".freeze
+        OTHER = "other".freeze
+        MAKARA_SUFFIX = "_makara".freeze
+
+        # convert vendor (makara, etc.) wrapper names to their bare names
+        # ex: postgresql_makara -> postgresql
+        def bare_adapter_name(adapter_name)
+          # TODO: OLD RUBIES - RUBY_VERSION < 2.5
+          # With Ruby 2.5+ we could use #delete_suffix instead of #chomp for a
+          # potential speed boost
+          return adapter_name.chomp(MAKARA_SUFFIX) if adapter_name && adapter_name.end_with?(MAKARA_SUFFIX)
+
+          adapter_name
+        end
 
-        def product_operation_collection_for name, sql, adapter_name
-          product   = map_product(adapter_name)
-          splits    = split_name(name)
-          model     = model_from_splits(splits)
+        def product_operation_collection_for(name, sql, adapter_name)
+          product = map_product(bare_adapter_name(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
+          NewRelic::Agent::Datastores::MetricHelper.product_operation_collection_for(product, operation, model, ACTIVE_RECORD)
         end
 
         SPACE = ' '.freeze
-        EMPTY = [].freeze
 
         def split_name(name)
           if name && name.respond_to?(:split)
             name.split(SPACE)
           else
-            EMPTY
+            NewRelic::EMPTY_ARRAY
           end
         end
 
         def model_from_splits(splits)
           if splits.length == 2
             splits.first
-          else
-            nil
           end
         end
 
@@ -135,16 +143,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 +163,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"
@@ -198,25 +206,24 @@ module NewRelic
         ACTIVE_RECORD_DEFAULT_PRODUCT_NAME = "ActiveRecord".freeze
 
         def map_product(adapter_name)
-          PRODUCT_NAMES.fetch(adapter_name,
-                              ACTIVE_RECORD_DEFAULT_PRODUCT_NAME)
+          PRODUCT_NAMES.fetch(adapter_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
 
@@ -225,13 +232,18 @@ module NewRelic
           SLASH = "/".freeze
           LOCALHOST = "localhost".freeze
 
+          def adapter_from_config(config)
+            bare_name = NewRelic::Agent::Instrumentation::ActiveRecordHelper.bare_adapter_name(config[:adapter])
+            PRODUCT_SYMBOLS[bare_name]
+          end
+
           def host(config)
             return UNKNOWN unless config
 
-            configured_value  = config[:host]
-            adapter = PRODUCT_SYMBOLS[config[:adapter]]
+            configured_value = config[:host]
+            adapter = adapter_from_config(config)
             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,16 +251,15 @@ module NewRelic
             else
               configured_value
             end
-
           rescue => e
-            NewRelic::Agent.logger.debug "Failed to retrieve ActiveRecord host: #{e}"
+            NewRelic::Agent.logger.debug("Failed to retrieve ActiveRecord host: #{e}")
             UNKNOWN
           end
 
           def port_path_or_id(config)
             return UNKNOWN unless config
 
-            adapter = PRODUCT_SYMBOLS[config[:adapter]]
+            adapter = adapter_from_config(config)
             if config[:socket]
               config[:socket].empty? ? UNKNOWN : config[:socket]
             elsif postgres_unix_domain_socket_case?(config[:host], adapter) || mysql_default_case?(config, adapter)
@@ -260,16 +271,15 @@ module NewRelic
             else
               UNKNOWN
             end
-
           rescue => e
-            NewRelic::Agent.logger.debug "Failed to retrieve ActiveRecord port_path_or_id: #{e}"
+            NewRelic::Agent.logger.debug("Failed to retrieve ActiveRecord port_path_or_id: #{e}")
             UNKNOWN
           end
 
           SUPPORTED_ADAPTERS = [:mysql, :postgres].freeze
 
-          def supported_adapter? config
-            config && SUPPORTED_ADAPTERS.include?(PRODUCT_SYMBOLS[config[:adapter]])
+          def supported_adapter?(config)
+            config && SUPPORTED_ADAPTERS.include?(adapter_from_config(config))
           end
 
           private