newrelic_rpm 6.15.0 → 9.7.1

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,17 +39,17 @@ 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
 
-            if RUBY_VERSION < "2.7.0"
+            alias_method(:delete_all_without_newrelic, :delete_all)
+
+            if RUBY_VERSION < '2.7.0'
               def delete_all(*args, &blk)
                 ::NewRelic::Agent.with_database_metric_name(self.name, nil, ACTIVE_RECORD) do
                   delete_all_without_newrelic(*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
@@ -93,33 +92,42 @@ module NewRelic
           end
         end
 
-        ACTIVE_RECORD = "ActiveRecord".freeze
-        OTHER         = "other".freeze
+        ACTIVE_RECORD = 'ActiveRecord'.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&.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)
+          if 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,83 +163,89 @@ module NewRelic
         end
 
         PRODUCT_NAMES = {
-          "mysql"      => "MySQL",
-          "mysql2"     => "MySQL",
+          'mysql' => 'MySQL',
+          'mysql2' => 'MySQL',
 
-          "postgresql" => "Postgres",
+          '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",
-          
+          '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"
+          'oracle_enhanced' => 'Oracle',
+
+          # https://rubygems.org/gems/activerecord-amazon-timestream-adapter
+          'amazon_timestream' => 'Timestream'
         }.freeze
 
-        ACTIVE_RECORD_DEFAULT_PRODUCT_NAME = "ActiveRecord".freeze
+        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,
-            "jdbcpostgresql" => :postgres,
-            "postgis"        => :postgres
+            'postgresql' => :postgres,
+            'jdbcpostgresql' => :postgres,
+            'postgis' => :postgres
           }.freeze
 
           DATASTORE_DEFAULT_PORTS = {
-            :mysql    => "3306",
-            :postgres => "5432"
+            :mysql => '3306',
+            :postgres => '5432'
           }.freeze
 
-          DEFAULT = "default".freeze
-          UNKNOWN = "unknown".freeze
-          SLASH = "/".freeze
-          LOCALHOST = "localhost".freeze
+          DEFAULT = 'default'.freeze
+          UNKNOWN = 'unknown'.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 +253,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,22 +273,21 @@ 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
 
           def postgres_unix_domain_socket_case?(host, adapter)
-            adapter == :postgres && host && host.start_with?(SLASH)
+            adapter == :postgres && host && host.start_with?(NewRelic::SLASH)
           end
 
           def mysql_default_case?(config, adapter)

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

@@ -1,11 +1,10 @@
-# 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_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
@@ -17,15 +16,16 @@ module NewRelic
 
         module BaseExtensions4x
           # https://github.com/rails/rails/blob/4-1-stable/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb#L371
-          def log(sql, name = "SQL", binds = [], statement_name = nil)
+          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
@@ -38,16 +38,17 @@ module NewRelic
 
         module BaseExtensions50
           # https://github.com/rails/rails/blob/5-0-stable/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb#L582
-          def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
+          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
@@ -55,20 +56,21 @@ module NewRelic
 
         module BaseExtensions51
           # https://github.com/rails/rails/blob/5-1-stable/activerecord/lib/active_record/connection_adapters/abstract_adapter.rb#L603
-          def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil) # :doc:
+          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
@@ -82,34 +84,19 @@ DependencyDetection.defer do
   named :active_record_notifications
 
   depends_on do
-    defined?(::ActiveRecord) && defined?(::ActiveRecord::Base) &&
-      defined?(::ActiveRecord::VERSION) &&
-      ::ActiveRecord::VERSION::MAJOR.to_i >= 4
+    defined?(ActiveRecord) && defined?(ActiveRecord::Base) &&
+      defined?(ActiveRecord::VERSION) &&
+      ActiveRecord::VERSION::MAJOR.to_i >= 4
   end
 
   depends_on do
-    !NewRelic::Agent.config[:disable_activerecord_instrumentation] &&
+    !NewRelic::Agent.config[:disable_active_record_instrumentation] &&
+      !NewRelic::Agent.config[:disable_active_record_notifications] &&
       !NewRelic::Agent::Instrumentation::ActiveRecordSubscriber.subscribed?
   end
 
-
-  depends_on do
-    # If the deprecated :disable_active_record_4 setting is true, and
-    # the active record version is four, disable!
-    NewRelic::Agent.config[:disable_active_record_4] == false \
-        || ::ActiveRecord::VERSION::MAJOR.to_i != 4
-  end
-
-  depends_on do
-    # If the deprecated :disable_active_record_5 setting is true, and
-    # the active record version is five, disable!
-    NewRelic::Agent.config[:disable_active_record_5] == false \
-        || ::ActiveRecord::VERSION::MAJOR.to_i  != 5
-  end
-
-
   executes do
-    ::NewRelic::Agent.logger.info 'Installing notifications based Active Record instrumentation'
+    NewRelic::Agent.logger.info('Installing notifications based Active Record instrumentation')
   end
 
   executes do
@@ -119,50 +106,51 @@ DependencyDetection.defer do
 
   executes do
     ActiveSupport.on_load(:active_record) do
-      ::NewRelic::Agent::PrependSupportability.record_metrics_for(
-          ::ActiveRecord::Base,
-          ::ActiveRecord::Relation)
+      NewRelic::Agent::PrependSupportability.record_metrics_for(
+        ActiveRecord::Base,
+        ActiveRecord::Relation
+      )
 
       # Default to .prepending, unless the ActiveRecord version is <=4
       # **AND** the :prepend_active_record_instrumentation config is false
-      if ::ActiveRecord::VERSION::MAJOR > 4 \
-          || ::NewRelic::Agent.config[:prepend_active_record_instrumentation]
+      if ActiveRecord::VERSION::MAJOR > 4 \
+          || NewRelic::Agent.config[:prepend_active_record_instrumentation]
 
-        ::ActiveRecord::Base.send(:prepend,
-            ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions)
-        ::ActiveRecord::Relation.send(:prepend,
-            ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions)
+        ActiveRecord::Base.send(:prepend,
+          NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions)
+        ActiveRecord::Relation.send(:prepend,
+          NewRelic::Agent::Instrumentation::ActiveRecordPrepend::RelationExtensions)
       else
-        ::NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_additional_methods
+        NewRelic::Agent::Instrumentation::ActiveRecordHelper.instrument_additional_methods
       end
     end
   end
 
   executes do
     if NewRelic::Agent.config[:backport_fast_active_record_connection_lookup]
-      major_version = ::ActiveRecord::VERSION::MAJOR.to_i
-      minor_version = ::ActiveRecord::VERSION::MINOR.to_i
+      major_version = ActiveRecord::VERSION::MAJOR.to_i
+      minor_version = ActiveRecord::VERSION::MINOR.to_i
 
       activerecord_extension = if major_version == 4
-        ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions4x
+        NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions4x
       elsif major_version == 5 && minor_version == 0
-        ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions50
+        NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions50
       elsif major_version == 5 && minor_version == 1
-        ::NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions51
+        NewRelic::Agent::Instrumentation::ActiveRecordNotifications::BaseExtensions51
       end
 
       unless activerecord_extension.nil?
-        ::ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:prepend, activerecord_extension)
+        ActiveRecord::ConnectionAdapters::AbstractAdapter.send(:prepend, activerecord_extension)
       end
     end
   end
 
   executes do
-    if ::ActiveRecord::VERSION::MAJOR == 5 \
-        && ::ActiveRecord::VERSION::MINOR.to_i == 1 \
-        && ::ActiveRecord::VERSION::TINY.to_i >= 6
+    if ActiveRecord::VERSION::MAJOR == 5 \
+        && ActiveRecord::VERSION::MINOR.to_i == 1 \
+        && ActiveRecord::VERSION::TINY.to_i >= 6
 
-      ::ActiveRecord::Base.prepend ::NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions516
+      ActiveRecord::Base.prepend(NewRelic::Agent::Instrumentation::ActiveRecordPrepend::BaseExtensions516)
     end
   end
 end

data/lib/new_relic/agent/instrumentation/active_record_prepend.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'
 
@@ -11,13 +11,13 @@ module NewRelic
         ACTIVE_RECORD = 'ActiveRecord'.freeze
 
         module BaseExtensions
-
-          if RUBY_VERSION < "2.7.0"
+          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
@@ -45,7 +46,7 @@ module NewRelic
           # Starting in v5.1.6, this call no longer happens. We'll
           # have to set the database metrics explicitly now.
           #
-          if RUBY_VERSION < "2.7.0"
+          if RUBY_VERSION < '2.7.0'
             def touch(*args, **kwargs, &blk)
               ::NewRelic::Agent.with_database_metric_name(self.class.name, nil, ACTIVE_RECORD) do
                 super
@@ -58,7 +59,6 @@ module NewRelic
               end
             end
           end
-
         end
 
         module RelationExtensions